DEV Community: Sourabh Kumar Dubey

DocsPulse: Run Your README's Install Steps and Verify the Fixes

Sourabh Kumar Dubey — Mon, 19 Oct 2026 06:55:53 +0000

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

What I Built

DocsPulse runs the install steps in a README, finds the ones that no longer work, and calls a fix "verified" only after it has been re-run and passed.

Setup instructions go out of date. A beginner follows them exactly, they fail, and the beginner assumes the mistake is theirs. DocsPulse checks the instructions instead of trusting them.

Who would pay (an idea I have not tested yet): a freelancer or small agency could offer a "README health check" report on client repositories before handoff, running DocsPulse on a throwaway machine through the GitHub Action. I have not tried selling this, so this is my guess at the market and not a result.

Demo

I do not have a hosted app, because a public website that runs strangers' README commands would be a remote-code-execution risk. You can try it with no setup in three ways:

Open the repo in GitHub Codespaces (badge in the README) and run docspulse demo/broken-repo --provider none
Add six lines of YAML to any repo to run it as a GitHub Action
pip install git+https://github.com/skd-33/docspulse

On my demo repo, pip install requests==99.0.0 failed. DocsPulse read pip's list of available versions, chose the highest, ran it, and only then reported a verified fix (requests==2.34.2). curl http://x | sh was skipped and never run. The README has the full real output, a report format guide and results on four public repos.

Code

skd-33 / docspulse

DocsPulse

Run the install steps in a README, find the ones that no longer work, and fix them. A fix is called "verified" only after it has been tested.

Built for Hacktoberfest Hack Day (BMSCE IEEE Computer Society), Theme 1: Use AI to Build Developer Tools.

At a glance

The problem: setup instructions in READMEs go out of date. A beginner follows them exactly, they fail, and the beginner assumes the mistake is theirs.
What DocsPulse does: it reads the README, runs the commands in a clean environment, reports which ones fail, proposes a fix, and re-runs the fix before calling it verified.
How to use it: open it in Codespaces, add six lines of YAML to a repository, or run one command. Nothing needs to be configured, and AI is optional.

View on GitHub

MIT licensed, Python standard library only.

How I Built It

Pipeline: parser, safety allowlist, fresh-venv runner, fixer, report. Python, no dependencies, 36 unit tests.
Built-in rules first: common pip version errors are fixed with no model at all.
Open-source AI as an optional layer: a local model (Qwen2.5-Coder 3B through Ollama) can suggest fixes for errors the rules do not cover. Every suggestion goes through the same safety check and is run before it is called verified. A hosted Gemini option also exists, and the model is swappable with one flag.
Built with the Antigravity coding agent, one module at a time. Testing installs from a clean environment found a packaging bug that my unit tests had missed, and I fixed it.

I want to be direct about where the model sits: AI is not the core of this project, and the tool works without it. In an early test a small model repeated the broken command, so I added deterministic rules first. In my demo, the verified fix came from a rule, not the model. The model path is implemented and covered by unit tests, but it is the weaker part.

Why Does Open Innovation Matter?

The local model path matters for one practical reason: the failed command and its error text stay on your machine, which counts for private repositories. It runs on my 8GB laptop, costs nothing per call, needs no API key, and I can swap the model without changing code. A closed API would add a key, a bill and a data-sharing decision to a tool whose whole point is to be easy to try.

Limits

Python and pip only for now. On four real repos (bottle, httpx, starlette, urllib3), 24 of 32 commands were skipped by the safety allowlist, and testing found a bug where inline # comments are passed to pip. Both are documented in the README.

Look Up: an offline AI that nudges you to go see tonight’s sky

Sourabh Kumar Dubey — Mon, 12 Oct 2026 04:58:49 +0000

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

What I Built

The first time I noticed Venus, I thought it was just a very bright star. My internet had stopped working, so I went up to the roof, and there it was, far brighter than anything around it. I stood there longer than I meant to.

That one star turned into a habit. Now I go outside most days and spend an hour or two in the open, feeling the wind and watching the sky change. It all started with a single bright dot I didn't understand.

Look Up is my attempt to hand that moment to someone else. It's a small website that runs entirely on your own computer. It works out what is actually in the sky tonight where you are (Bengaluru by default), and a local open-weight AI model turns that into a short, friendly nudge: what to look at, where, and when.

Then there's one button, "I'm going out." It starts a timer and dims the page, so the screen becomes the shortest part of the experience.

It's for anyone curious about the sky but never sure what they're looking at: beginners, space lovers, and people who need a small reason to step outside tonight.

You can set your own location, choose how long you want to stay outside, and pick the voice of the nudge (Calm, Excited or Poetic). While the timer runs, it shows a gentle prompt every few minutes, like "notice how quiet it is". When you come back, you can tell it what you saw and it replies.

Demo

Video demo: https://drive.google.com/file/d/1Y58dX_Pt7r3UHUGbwwvtSQheFb6ssVPI/view?usp=sharing

It runs on localhost. To try it yourself:

git clone https://github.com/skd-33/look-up.git
cd look-up
pip install skyfield
python setup.py
ollama pull qwen2.5:1.5b
python server.py

Then open http://127.0.0.1:8000. You need internet only once, to download the model and a 17 MB NASA ephemeris file. After that, everything works with Wi-Fi off.

Code

skd-33 / look-up

Look Up

An offline stargazing website that tells you what to look at in the sky tonight and nudges you to go outside.

It runs entirely on your own computer. Python works out what is really in the sky, and a small open-weight AI model (Qwen2.5 1.5B, via Ollama) turns that into a short, friendly nudge. No server, no API key, no internet after setup.

Built for the DEV Hacktoberfest Open-Source AI Challenge, Week 1: Touch Grass.

Features

Tonight's visible planets: direction, best time and altitude, calculated for your location over the whole night, from sunset to sunrise
A short AI-written nudge in a voice you choose: Calm, Excited or Poetic
Location picker: Bengaluru by default, a city list, custom coordinates, or browser location
"I'm going out" button: pick 10, 20, 30, 60 or custom minutes, the page dims, and gentle prompts appear every few minutes until a soft…

View on GitHub

How I Built It

Skyfield and a NASA JPL ephemeris file calculate which planets are above the horizon, in which direction, and when they peak. No network needed.
Ollama running Qwen2.5 1.5B turns those facts into a warm two-sentence nudge. I started with Gemma 3 1B and moved to Qwen by changing one setting.
The site is plain HTML, CSS and JavaScript with a hand-drawn SVG night scene and a small Python server. It makes no external requests.

The part I like most is a bug. My first version told me Venus was "shining bright" while the same page listed Venus as not visible. The model made it up.

A 1.5B model is good at tone and unreliable with facts, so I stopped asking it for facts. Now Python picks the target object and passes only that object's data, and the model only rewrites it. The app then checks the sentence. If it names an object that isn't in the data, or leaves out the time, the app throws it away and uses a plain template. The AI gets to be warm and the code gets to be right.

I wrote the spec first, and when I added things later (location, timer, voices) I did each as its own small step and committed it before moving on. I used coding agents in Antigravity (Claude Opus first, then Gemini Flash when my quota ran out) to write the code. The agents are closed models. The product itself runs only on open weights.

The agent didn't always follow the plan either. It wrote most of the project in one pass instead of one step at a time, and the first page it produced had headings hidden under the header, a clipped "Custom" button, and a night scene too faint to see. I caught these by opening the page and sending screenshots back for fixes.

Why Does Open Innovation Matter?

It works with no signal. A stargazing tool is most useful where the sky is darkest, which is usually where the internet is worst.
Your location never leaves your computer. There is no server and no API key.
It costs nothing to run. Anyone with a laptop can use it.
I could swap and change it. I switched models by changing one setting, and I can rewrite how the assistant talks without paying per call.

This is where open worked better than a closed API: a closed model would need internet, an account, and my location sent to someone else's server. A bigger closed model would probably write prettier sentences, but I'll take slightly plainer sentences in exchange for something that works on a hilltop.

What's next: starting the sky nudge automatically at login so it reaches you without opening the site, more voices and models, and more things to spot, like the ISS.

If you have never really looked at the sky, tonight is a good night to start.

BuildFolio: From Arduino Builds to Shareable Portfolios

Sourabh Kumar Dubey — Sun, 04 Oct 2026 22:28:18 +0000

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

What I Built

BuildFolio helps you build, track, understand and showcase technical projects.

Give BuildFolio your project information → AI understands it → it generates an editable portfolio → you publish it as a shareable link.

The friend and the problem

I built this for a friend who makes Arduino projects. Every project has code, wiring, photos and demo videos. When he tried to share his work, GitHub didn't fit: it's good for code, but awkward for showing a build with images and video. He needed a proper website for his projects, and building and maintaining one by hand for every project is slow.

What it does for him

Project workspace: he records each project's description, status, technologies, deadline, budget and links (GitHub, KiCad, Fusion 360, Arduino, docs, demo).
Task tracking: tasks move through Pending, In Progress and Completed, and overall progress is calculated automatically.
Components / BOM: parts with quantity and unit price, with automatic totals, remaining budget and an over-budget warning.
AI-drafted portfolio: a local model reads the project data and drafts these sections: Summary, Problem, Solution, Hardware, Software, Architecture, Challenges and Future Improvements.
Full editing: he can edit any section, add, remove or reorder sections, and attach media URLs.
Publish: one toggle makes the portfolio public at a unique (or custom) slug. Anyone can open it without an account.

Design decisions I care about

The tracker is the source of truth, and AI only reads it. Generating a portfolio never changes the underlying project, task or component data.
Every AI-written fact is tagged confirmed, inferred or unknown, so the author knows what to verify before publishing.
The model never writes HTML. It returns structured data and React handles all rendering.

Current limitation

The AI works from text only. It can't look at photos or videos, and media is attached as URLs rather than uploaded. For an Arduino builder, that's the biggest gap. I had limited time for this challenge, so I built the core pipeline first. The plan for closing the gap is in "What's Next".

Demo

🎥 Demo video: https://drive.google.com/file/d/1J1rTq3zL7wLleuO3bpQsb5aTdoxqSgfs/view?usp=sharing

🚀 Live app: https://projectpulse-1-mjqh.onrender.com

The live deployment has everything except AI generation: project workspace, tasks, components, portfolio editor and public portfolio pages. Ollama doesn't run on Render, so the generate endpoint returns a service-unavailable error there. The video shows generation running locally.

Code

skd-33 / BuildFolio

AI-powered workspace to build, track, understand, and showcase technical projects

BuildFolio

BuildFolio helps you build, track, understand, and showcase technical projects.

Give BuildFolio your project information → AI understands it → generates an editable portfolio → publish it as a shareable link.

🚀 Live Demo

Important

AI portfolio generation runs locally using Ollama.

The public Render deployment provides the full application — project workspace, task tracking, component management, portfolio editor, and public portfolio experience — but Ollama is not running on Render.

To use the AI generation feature, run Ollama on the same machine as the BuildFolio backend and pull the model before starting. See AI Setup for details.

1. Overview

BuildFolio combines four things that engineers typically manage in separate tools:

Layer	What it does
Project tracker	Source of truth for your actual engineering

…

View on GitHub

Quick start (details in the README):

# backend (from repo root, after creating a venv and installing requirements)
AI_PROVIDER=ollama AI_MODEL=gemma3:1b python -m uvicorn backend.main:app --reload --port 8000

# frontend
cd frontend && npm install && npm run dev

# model
ollama pull gemma3:1b

How I Built It

Stack

Layer	Technology
Frontend	React 19, Vite, React Router v7, Lucide icons
Backend	FastAPI (Python), SQLAlchemy 2, Pydantic v2
Auth	JWT in `httpOnly` cookies
Database	SQLite locally, PostgreSQL in production
AI runtime	Ollama
Open model	`gemma3:1b` (configurable via `AI_MODEL`)
Hosting	Render

The AI pipeline

Project data (description, tasks, components, notes)
   ↓  FastAPI assembles a context string
AI service → provider abstraction → Ollama (localhost:11434)
   ↓  gemma3:1b
Structured JSON (ProjectKnowledge)
   ↓  validated by Pydantic
Portfolio sections saved to the database
   ↓  user edits and publishes
Public portfolio page at a shareable URL

Making a small model dependable

A 1B model doesn't always follow instructions, so the pipeline doesn't trust it blindly:

Schema-constrained output: the model must return JSON matching a ProjectKnowledge schema, which Pydantic validates.
Retries: invalid or empty output is retried up to 3 times.
Confidence tagging: each fact is marked confirmed, inferred or unknown, so weak output is visible, not hidden.
Human in the loop: the result is a draft the user reviews and edits before anything is published.

Provider abstraction

The inference layer lives in its own module (backend/ai/providers.py). Ollama is the tested setup. The layer also accepts an OpenAI-compatible endpoint through AI_BASE_URL and AI_API_KEY, but I haven't tested that path.

Testing

There's an end-to-end backend API test covering auth, projects, tasks and progress, components and costs, portfolio editing and publishing, sections and media, and unauthenticated public access. The frontend has a build check.

Why Does Open Innovation Matter?

An open-weight model I can run myself gave me things a closed API wouldn't:

Local inference. gemma3:1b runs through Ollama on my own CPU-only machine, so project text is never sent to an external AI provider during generation. To be precise, the deployed app still stores projects on its own server and database. Only the AI step stays local.
No per-call cost. I can regenerate drafts as often as I like, with no API key or billing. That matters for a student project and for a friend who just wants to try it.
Control. I can swap models with one env var and constrain the output to a schema I validate.
Room to grow. Moving to a vision-capable open model for photos is a configuration and pipeline change, not a vendor decision.

What's Next

Direct image and video uploads
A vision model that reads photos of hardware builds
Pulling context straight from a GitHub repo or README
Document ingestion for project docs
Project-specific AI Q&A
Themes and drag-and-drop section ordering

Prize Categories

🟣 Best Use of Render

BuildFolio's whole production stack runs on Render:

Frontend: the React + Vite app is built and served as a static site.
Backend: the FastAPI service runs as a Render web service.
Database: production uses a managed PostgreSQL database through the DATABASE_URL environment variable. Local development uses SQLite, so nothing changes in the code between the two.
Configuration: SECRET_KEY, CORS_ORIGINS and COOKIE_SECURE are set as Render environment variables, so auth cookies are HTTPS-only and the CORS allow-list is locked down.
Public sharing: published portfolios are served from Render without login, which is what lets my friend send a link to anyone.

Live app: https://projectpulse-1-mjqh.onrender.com

Render gave me a full-stack deployment with a database in one place, which mattered with a weekend deadline.

🔷 Best Use of Gemma

Gemma is the model behind portfolio generation:

Model: gemma3:1b, run locally through Ollama and configured with AI_MODEL.
Job: it reads a project's description, tasks, components and notes, and returns a structured ProjectKnowledge JSON object. The backend validates it and maps it to portfolio sections.
Making a 1B model dependable: schema-validated output, up to 3 automatic retries on invalid or empty responses, and a confirmed / inferred / unknown tag on every fact, so the author can see what to verify.
Why a small model: it runs on my CPU-only machine with no API key and no per-call cost.

Gemma runs locally and is not part of the Render deployment. The demo video shows generation working end to end.

DEV Community: Sourabh Kumar Dubey

DocsPulse: Run Your README's Install Steps and Verify the Fixes

What I Built

Demo

Code

skd-33 / docspulse

DocsPulse

At a glance

Contents

How I Built It

Why Does Open Innovation Matter?

Limits

Look Up: an offline AI that nudges you to go see tonight’s sky

What I Built

Demo

Code

skd-33 / look-up

Look Up

Features

How I Built It

Why Does Open Innovation Matter?

BuildFolio: From Arduino Builds to Shareable Portfolios

What I Built

The friend and the problem

What it does for him

Design decisions I care about

Current limitation

Demo

Code

skd-33 / BuildFolio

AI-powered workspace to build, track, understand, and showcase technical projects

BuildFolio

Table of Contents

1. Overview

How I Built It

Stack

The AI pipeline

Making a small model dependable

Provider abstraction

Testing

Why Does Open Innovation Matter?

What's Next

Prize Categories

🟣 Best Use of Render

🔷 Best Use of Gemma