QuietPatch: Building an AI-Powered Repository Caretaker with Google Gemma and Reviewable Code Fixes

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

What I Built

I built QuietPatch — an AI-powered repository caretaker that helps developers find, understand, and fix common maintenance issues in their codebases without manually inspecting every file.

QuietPatch combines deterministic code scanners with Google Gemma to analyze findings, prioritize issues, and generate reviewable code patches. It then runs verification checks and creates a maintenance report so developers can understand what was found, what was evaluated, and which fixes were proposed.

The key idea is to make repository maintenance less repetitive. Instead of manually searching for TODOs, checking configuration files, investigating broken documentation links, prioritizing issues, and drafting fixes from scratch, developers can use QuietPatch to automate much of that initial work.

Safety is built into the workflow: proposed patches remain reviewable, and developers must explicitly approve changes before they are applied. QuietPatch does not automatically commit or push code.

I built it to explore how AI agents can make software maintenance easier while keeping developers in control. The goal is simple: less time spent on repetitive codebase housekeeping, more time spent building and shipping software.

Demo

quietpatch.onrender.com

Code

Harshit10-LM / QuietPatch

A local-first AI repository caretaker powered by Gemma and Ollama. Detects technical debt, explains code maintenance issues, generates reviewable fixes, and traces agent workflows with Sentry.

QuietPatch 🌿

Your project works. QuietPatch makes it ready to ship. A local-first AI repository caretaker powered by Gemma for Hacktoberfest 2026 DEV Open-Source AI Challenge, Week 3: "Slow and Steady."

---

1. What QuietPatch Does

Every engineering team accumulates maintenance tasks that get continually postponed: broken internal markdown links, undocumented environment variables causing staging outages, unpinned dependencies, missing packaging scripts, and lingering # TODO and # FIXME comments.

QuietPatch is not another general-purpose AI chat bot or hallucinating code generator.

Instead, it acts as a deliberate, slow-and-steady repository caretaker:

1. Deterministic Discovery & Scanning: Discovers files while strictly respecting .gitignore and security limits; executes real AST and pattern scanners across documentation, configuration, TODOs, Python, and TypeScript.
2. Gemma-Powered Analysis & Prioritization: Feeds grounded evidence to an open-weight Gemma model to explain why each defect matters and assign a realistic severity (critical, high, medium, low, informational).
3. …

View on GitHub

How I Built It

I built QuietPatch around Google Gemma, an open-weight AI model family, with a workflow that combines deterministic code analysis and AI-assisted maintenance.

The AI behind QuietPatch

I use two execution modes:

• Local inference: Gemma 4 E4B through Ollama, allowing developers to run AI analysis on their own machines without sending repository snippets to a hosted AI provider.
• Hosted inference: Gemma 4 26B A4B Instruct through Google's Gen AI API, powering the publicly deployed demonstration on Render.

This dual-mode approach lets QuietPatch explore both local-first development and a hosted experience that people can access without installing the entire application.

How the agent works

I built a Python and Flask backend that coordinates the maintenance workflow:

1. Discover: Inspect the repository structure and identify supported files.
2. Scan: Use deterministic Python scanners to find maintenance issues, such as TODO/FIXME markers, broken documentation links, and configuration inconsistencies.
3. Analyze: Send relevant findings and bounded source context to Gemma for explanations and prioritization.
4. Propose: Ask the model to generate targeted, reviewable edits for eligible findings.
5. Validate: Check the proposed changes against the original files and enforce path and patch-safety rules.
6. Report: Present findings, proposed fixes, verification outcomes, and maintenance-run status in the dashboard.

An important design decision was to keep deterministic scanning separate from AI reasoning. The scanner establishes the evidence, while Gemma helps interpret it and suggest possible fixes. This makes it easier to distinguish confirmed findings from AI-generated recommendations.

The rest of the stack

• Frontend: React, TypeScript, and Vite.
• Backend: Python and Flask.
• Local AI: Gemma 4 E4B with Ollama.
• Hosted AI: Gemma through the Google Gen AI API.
• Deployment: Render.
• Observability: Sentry for tracking maintenance runs, model calls, latency, and failures.

I implemented background maintenance execution so long-running AI work does not need to keep the initial HTTP request open. Sentry tracing helps investigate failures across the different stages of the workflow.

Keeping developers in control

QuietPatch does not automatically commit or push AI-generated changes. Proposed patches are presented for review, and changes must be explicitly approved before application.

Hosted inference also has a clear privacy boundary: selected repository snippets are sent to Google's API. Local inference is available for developers who prefer to keep that analysis on their own machines.

The project is still evolving. Hosted models can return transient errors, time out, or produce unusable output, so I have been working on bounded retries, response validation, and preserving successful results when individual proposals fail. Those challenges have been an important part of learning how to build AI-assisted developer tools responsibly.

My main takeaway is that building an AI agent is not just about connecting a model to an API. It also requires deterministic checks, safe edit handling, clear state management, observability, and honest reporting when the model cannot complete a task.

Why Does Open Innovation Matter?

Open innovation made it possible to build QuietPatch around Google Gemma, with the flexibility to run AI locally through Ollama or use hosted inference through Google's Gen AI API.

This gives developers more choice over how their code is analyzed. Local inference helps keep repository snippets on their own machines, while the hosted version makes QuietPatch accessible through a public demo.

Working with Gemma also let me experiment with how open-weight AI can handle real developer workflows, from understanding maintenance issues to proposing reviewable fixes.

For me, open innovation means having the freedom to experiment, build, and adapt AI to practical problems—while keeping developers in control.

The Lazy Payoff

I tested QuietPatch on its sample repository, where it scanned 8 files and identified 14 maintenance findings. In one run, it also generated two reviewable patches.

The biggest benefit is reducing the repetitive work of finding issues, understanding them, and preparing fixes. I haven't measured the exact time saved yet, and hosted AI can still fail on some patch proposals, so there's more room to improve.

For now, QuietPatch helps turn manual repository housekeeping into a workflow that developers can review instead of starting from scratch.

Prize Categories

• Best Use of Render — Hosting and deploying the public QuietPatch application.
• Best Use of Gemma — Using Google Gemma for repository analysis and AI-assisted patch proposals.
• Best Use of Sentry Agent Tracing — Tracing maintenance runs and monitoring agent-stage performance and failures.