DEV Community: Priyanshu Gupta

DawnPatch: Let Your Laptop Reproduce the Bug Before You Touch the Code

Priyanshu Gupta — Fri, 23 Oct 2026 07:51:05 +0000

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

What I Built

The part of fixing a website bug that I keep putting off is getting everything into one place: the reproduction steps, the failing screen, the relevant source, the proposed change, and proof that it helped.

I built DawnPatch, a local maintainer workbench that turns that process into a reviewable investigation.

Give it an authorized local repository, an issue, and browser steps with assertions. DawnPatch reproduces the behavior in Chromium, captures evidence, asks a local Gemma model for a small source change, and tests the candidate in a separate source copy. The maintainer gets a report, a diff, and the results of replaying the same checks.

Its rule is simple: a proposed repair has to earn its passing result.

The desktop workbench: a quiet place to queue investigations and review their evidence.*

The workbench includes:

An investigation queue with visible stages and recorded activity.
Real browser reproduction, screenshots, and downloadable Playwright traces.
Local Gemma analysis through a typed Mastra workflow.
Bounded source edits with exact-match validation and rejection of unchanged proposals.
Separate baseline and candidate workspaces, with build checks and browser replay.
Evidence comparison, source diffs, reports, and patch exports.
An explicit developer-correction path when the model needs help.
Daily schedules, a morning brief, and Temporal workflows with worker-failure recovery.

The interface takes inspiration from instrument panels: dark surfaces, fine dividers, readable typography, and status information you can inspect. I wanted the work to be visible while a small local model takes its time.

Demo

Watch the narrated desktop demonstration — approximately 3 minutes 15 seconds

DawnPatch runs locally; the video shows the actual website UI rather than a hosted application.

For the demonstration, I used my SketchWild repository as the target. In an isolated test checkout, I deliberately reversed its mission-duration comparison. Selecting “Up to 5 minutes” then returned six missions instead of the expected one. This was a controlled regression for evaluating DawnPatch, not a newly discovered upstream bug.

Before: the five-minute filter incorrectly includes longer missions.

DawnPatch reproduced that failure. Gemma 3:4b did not produce a successful repair in the recorded investigation, so I supplied the exact correction through the developer-correction form. DawnPatch labels that origin explicitly, builds a separate candidate, and independently replays the browser steps.

After the developer-assisted correction: only the expected five-minute mission remains.

The complete replay checks more than that first screen: twenty minutes must show all six missions, and the courtyard filter must still show four. All eight recorded steps passed for the corrected candidate.

Verification covers the failing baseline, an isolated build, and replay against the candidate.

I also tested the healthy upstream revision. It passed the checks and finished without a patch. A passing website should not get a speculative “repair.”

Long inference waits and recording setup are cut from the video. The narration preserves the outcome: this is a developer-assisted repair with automated verification, not a successful autonomous Gemma repair.

Code

Repository: priy-anshugupta/DawnPatch

The repository includes the application, setup instructions, automated checks, test evidence, and demo documentation. DawnPatch is MIT-licensed.

Detailed SketchWild test report · Demo notes

How I Built It

The frontend uses React, TypeScript, and Vite. A local Express API coordinates investigations, while SQLite stores runs, ordered events, schedules, and checkpoints.

Ollama runs the open-weight Gemma 3:4b model locally. A Mastra workflow gathers a bounded selection of relevant source and asks for structured analysis and exact edits. The model's output is treated as a proposal that still needs validation.

Playwright and Chromium provide the behavioral evidence. Baseline and candidate use the same reproduction steps and assertions. For the SketchWild repository test, Docker builds and serves an isolated candidate; the original target repository is left unchanged.

The workflow is:

Prepare an isolated source copy.
Reproduce a failing behavioral assertion and save its evidence.
Gather relevant source and request a bounded model proposal.
Validate exact edits and build the candidate.
Replay the same browser checks.
Present the evidence and diff for human review.

The reviewed change restores the maximum-duration comparison; its developer-assisted origin remains visible.

One useful failure happened before the final recording: a model proposal used equality instead of a maximum-duration comparison. It satisfied the five-minute case but failed the twenty-minute check. DawnPatch kept the failed result instead of calling it verified. That test made the extra assertion worth having.

Temporal powers the durable workflow backend. I tested worker-failure recovery by terminating and restarting a worker during an investigation. The same investigation completed with its captured baseline preserved. The recovery evidence records the run and stage events. This test used a known fixture repair; the SketchWild video uses the local SQLite queue.

SerpApi provides optional documentation discovery. Search results are labeled as discovery snippets, and search was disabled for the recorded SketchWild investigation. GitHub Actions automates repository verification with a public successful workflow run. ElevenLabs generated the demo narration; it is a production tool for the video, not a dependency of the repair pipeline.

Sentry instrumentation covers investigation stages, model spans, and errors with redaction of sensitive data. I also installed and configured Entire for Codex development-session capture. The current submission does not include a verified shareable Entire recording or a Sentry dashboard trace, so these setup details are not presented as completed prize-category evidence.

For the latest local build, 11 core/transport tests and 7 browser tests passed, alongside TypeScript checking and the production build. Those checks cover edit validation, cancellation, correction provenance, replay, connection recovery, and desktop review flows. They do not establish that the model can autonomously fix arbitrary bugs.

Why Does Open Innovation Matter?

Running Gemma locally lets me experiment with the agent while keeping model inference on my own machine. I can change the context budget, inspect the structured output, adjust the prompts, and choose a different installed model without rebuilding the browser-verification pipeline around a particular hosted provider.

That flexibility mattered during this build. A small model on a laptop was slow and sometimes wrong. Being able to inspect its proposals helped me improve filename grounding, reject no-change edits, and preserve a useful human-correction path.

Ollama, Mastra, Playwright, and Temporal also make the workflow inspectable. Contributors can examine how a source file was selected, why an edit was rejected, and which browser assertion failed.

A closed API could power a similar tool. The benefit here is control over the inference runtime and the workflow around it. Optional search, telemetry, GitHub publication, and narration services still need network access; local inference does not make every integration offline.

The Lazy Payoff

I used DawnPatch this week to run the controlled SketchWild regression through reproduction, correction, and verification.

The payoff is fewer repeated steps: the browser records the failing behavior, the candidate gets its own build, the same assertions run again, and the report keeps the diff beside the evidence. I can spend my attention reviewing the result instead of assembling that evidence by hand.

The handoff: observed behavior, repair provenance, verification, and the next review action.

I have not measured a reliable time-saving percentage yet. The demonstrated benefit is repeatable evidence collection and a clearer review handoff, even when the model needs help.

Monitoring and Debugging with Sentry

Prize Categories

Best Use of Gemma — local Gemma 3:4b analysis and bounded patch proposals through Ollama.
Best Use of Mastra — typed context-gathering and model-analysis workflow.
Best Use of Temporal — durable investigation workflows with tested worker-failure recovery and preservation of the captured baseline. Recovery evidence.
Best Use of SerpApi — opt-in live documentation discovery.
Best Use of GitHub Copilot — GitHub Actions automation for repository verification. Successful workflow run.
Best Use of ElevenLabs — generated English narration for the demonstration video.
Best Use of Entire — Entire CLI installed and configured for Codex development-session capture and checkpoints.
Best Use of Sentry Agent Tracing — DawnPatch includes instrumentation for investigation stages and model calls, error capture, and sensitive-value redaction. The screenshots show received testing errors and the dawnpatch.check connection trace. Model-call traces and token metrics are not yet verified in the dashboard.

SketchWild: Draw Outside,Look Closer

Priyanshu Gupta — Sat, 10 Oct 2026 05:39:23 +0000

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

🌿 What I Built

SketchWild is an outdoor sketching companion that helps you slow down, draw on paper, and notice more of the world around you.

Sometimes, “go outside” is too vague. You reach a park or garden, but still don’t know what to do. SketchWild gives you a small, concrete exercise: study a leaf’s edge, follow the overlap of flower petals, or sketch the empty spaces between tree branches.

You don’t need to be an artist. A nearby flower, a balcony plant, or a rock beside a path is enough. The aim is to pay attention, rather than produce a perfect picture.

After drawing, upload a photograph of your subject alongside a photograph of your paper sketch. Gemma 3, running locally through Ollama, compares the pictures and offers one detail to explore.

You can then return to the real subject, add a small drawing or annotation, and record what you noticed in your journal. The model supports the observation; your pencil and the real world remain at the centre of the experience.

Choose a mission. Draw outside. Look again. Keep your discovery.

SketchWild is for beginners who need a starting point, nature journalers who enjoy recording details, and people looking for a short outdoor break.

What you can do

Choose a subject: Leaves, flowers, trees, bark, rocks, or outdoor scenes.
Take an outdoor mission: Six exercises exploring shapes, overlap, texture, light, negative space, and depth.
Make it fit your day: Filter missions by place and available time, or print the instructions.
Get a second-look invitation: Compare your subject and sketch using local Gemma.
Keep a field journal: Save reflections and follow-up drawings, revisit studies, and export a ZIP backup.
Collect Field Passport stamps: Record self-reported outdoor participation without grading your art.

The screen provides a starting point and a moment of reflection. The drawing happens on paper, outside.

🚀 Demo

🌐 Public Website

Open SketchWild →

Explore outdoor missions, upload pictures, save reflections, and try the journal.

Live model inference is disabled in the public preview. The site clearly links to local setup instructions, the video walkthrough, and a labelled feedback example.

▶️ Video Walkthrough

Watch SketchWild on YouTube →

The walkthrough shows the sketching flow and a live Gemma comparison running locally through Ollama.

The uploaded pictures are generated samples used to demonstrate the workflow. The processing wait is shortened in the edit; this is not an outdoor participant trial.

💻 Code

The complete application and local setup instructions are available on GitHub.

View the SketchWild repository →

Application code is MIT licensed. Model weights and dependencies retain their own terms.

🛠️ How I Built It

I built SketchWild around two connected experiences: a guided outdoor sketching workflow and a local vision-model comparison.

The interface uses React and TypeScript. An Express backend prepares the uploaded pictures, calls Gemma 3 through Ollama, and checks the response before displaying it.

Missions, journal storage, and passport progress use ordinary application logic. The model compares the two pictures and suggests an observation.

Technology Stack

Layer	Technology
Frontend	React 19, TypeScript, Vite
Styling	Custom responsive CSS
Icons	Lucide
Backend	Node.js, Express
Local vision model	Gemma 3 4B
Model runtime	Ollama
Image processing	Browser normalization, Sharp
Response validation	Zod
Journal storage	IndexedDB
ZIP export	fflate
Public hosting	Render
Demo narration	ElevenLabs

System Architecture

Local version — live Gemma feedback

Browser: React interface
Missions · uploads · reflections
            │
            ├── IndexedDB
            │   Drafts · pictures · journal
            │
            ▼
Local Express API
Validate and prepare both pictures
            │
            ▼
Ollama → Gemma 3 4B
Compare subject and paper sketch
            │
            ▼
Express validates the response
            │
            ▼
Browser displays the coaching card

Public preview — hosted on Render

Visitor's browser
            │
            ▼
Render: Express serves the React app
            │
            ▼
Missions · uploads · reflections
            │
            ▼
Journal saved in the visitor's IndexedDB

Live inference: disabled
Links: local setup · walkthrough · example

The public website does not automatically connect to a visitor’s Ollama installation. Live coaching requires running the application and model locally.

How the comparison works

The user uploads the subject photograph and paper sketch.
The backend validates and prepares both images.
Ollama passes the pair to Gemma with explicit subject/drawing labels.
The prompt asks for visible evidence from both pictures and one respectful observation.
The backend validates the response before showing the coaching card.

Unclear pictures can produce uncertainty or a retake request. Failed requests show an error rather than silently substituting example feedback.

What I learned

Local CPU inference takes patience. One recorded sample comparison took approximately 146 seconds on my laptop.

I added elapsed-time feedback, cancellation, draft persistence, and an option to save without model feedback.

A GitHub Copilot review identified confusing preview wording and missing accessible dialog title associations. Both findings were checked and corrected.

The current build passes 17 automated tests, TypeScript checking, and the production build. These checks verify application behavior, not visual accuracy.

🔓 Why Does Open Innovation Matter?

Pictures can stay on your computer

In local mode, the selected pictures are processed by Ollama on the computer running SketchWild. A cloud model service is not required.

Journal entries stay in the current browser. There is no account synchronization, so ZIP export provides a way to keep a backup.

No model API key is needed locally

After downloading the dependencies and model, local comparison can run without a cloud inference connection.

There is no per-request cloud inference fee, although the laptop supplies the memory, processing time, and electricity.

The coaching can be changed

Open weights and application source let me edit the observation prompt, adjust image preparation, and swap compatible vision models.

This gives me a practical way to experiment with the coaching instead of depending on one closed service.

The tradeoffs are visible

CPU responses can be slow, and a model can misinterpret a drawing. A structurally valid answer is not necessarily an accurate observation.

My next priorities are evaluation with real subject photographs and paper sketches across all six categories, followed by an outdoor user trial.

🏆 Prize Categories

Best Use of Gemma: Local subject-and-sketch observations using Gemma 3 4B through Ollama.
Best Use of Render: Hosting the public frontend and backend preview.
Best Use of ElevenLabs: Generating narration for the project walkthrough.
Best Use of GitHub Copilot: Reviewing preview behavior and accessibility, with two findings checked and corrected.

The observation-first approach was informed by Bio Sketchbook and John Muir Laws’ nature journaling practices. SketchWild’s implementation, interface, and exercise prompts are original.

Hacktoberfest 2026: Building with Open-Source AI

Priyanshu Gupta — Thu, 08 Oct 2026 17:56:54 +0000

Hey everyone! 👋

I’m Priyanshu, a third-year IT student and AI/ML enthusiast.

Hacktoberfest 2026 is taking a different direction this year — and I’m genuinely excited about it.

This time, I’m not here to chase PR counts. I want to spend October building, experimenting, and learning with open-source AI and open-weight models. 🤖

I’ve mostly worked with GenAI applications, RAG pipelines, AI agents, and frameworks like LangChain, LangGraph and FastAPI.

For Hacktoberfest, I want to take that a step further:

→ Experiment with open-weight models and local inference

→ Build an AI project around an actual problem

→ Explore open-source agent frameworks

→ Learn how open AI systems compare with proprietary APIs

→ Document what I learn and share the journey here

I’m especially interested in seeing what other developers are building and experimenting with this month.

No PR counter. No contribution farming.

Just build → experiment → learn → share. 🚀

Let’s see what we can create with open-source AI.

hacktoberfest #opensource #ai #machinelearning