Building an AI-Powered Git Diff Reviewer: Catch Bugs Before You Push

Humam Moin — Mon, 12 Oct 2026 14:08:18 +0000

Hey dev.to! 👋

Have you ever pushed a commit in a hurry, only to realize later that you introduced a critical security flaw or a silly bug? We've all been there. The "oops, I'll fix it in the next commit" cycle is a rite of passage for developers.

What if you had a senior developer looking over your shoulder before you even push?

That's exactly why I built Git Diff Reviewer, a CLI tool that integrates directly into your Git workflow. When you commit, it automatically extracts your diff, sends it to an LLM (Gemini, OpenRouter, Groq, or local Ollama), and gives you a structured review right in your terminal.

Let's dive into how it works and how you can set it up!

🛠️ What is Git Diff Reviewer?

Git Diff Reviewer is a pre-commit hook that acts as your personal AI code reviewer. Instead of waiting for CI/CD to fail or a teammate to catch a bug, you get instant feedback.

Key features

Multi-Provider Support: Gemini for deep capability, Groq for ultra-low latency, OpenRouter for flexibility, or Ollama for 100% local privacy.
Strict Review Taxonomy: It doesn't just say "this looks bad." It categorizes issues (see the table below).
Pre-commit Hook: Runs automatically on git commit. Zero friction.
.reviewerignore: Filters out lockfiles, build outputs, and .env files so you don't waste tokens.
Fully Tested: Comes with 22 unit tests to ensure reliability.

Category	What it catches
Critical Bugs	Logic errors, infinite loops
🔒 Security Vulnerabilities	SQL injection, XSS, hardcoded secrets (aligned with OWASP/CWE)
⚠️ Anti-patterns	Code smells and bad practices
⚡ Performance Bottlenecks	N+1 queries, inefficient loops

How It Works (Architecture)

┌──────────────────────────────────────────┐
│   git commit -m "feat: update auth"      │
└────────────────────┬─────────────────────┘
                     ▼
┌──────────────────────────────────────────┐
│   Pre-commit hook                        │
│   python main.py --staged                │
└────────────────────┬─────────────────────┘
                     ▼
┌──────────────────────────────────────────┐
│   Extract staged diff                    │
│   + filter files via .reviewerignore     │
└────────────────────┬─────────────────────┘
                     ▼
┌──────────────────────────────────────────┐
│   LLM Provider                           │
│   Gemini │ Groq │ OpenRouter │ Ollama    │
└────────────────────┬─────────────────────┘
                     ▼
┌──────────────────────────────────────────┐
│   Structured review printed in terminal  │
└──────────────────────────────────────────┘

🚀 Setup & Installation

Let's get this running on your machine.

1. Clone the repository

git clone https://github.com/humammoin09-blip/git-diff-reviewer.git
cd git-diff-reviewer

2. Create and activate a virtual environment

python -m venv .venv

# Windows:
.\.venv\Scripts\Activate.ps1

# Mac/Linux:
source .venv/bin/activate

3. Install dependencies

pip install -r requirements.txt

4. Set up environment variables

Copy the example file and add your API key:

cp .env.example .env

Open .env and configure your provider (e.g., Gemini):

LLM_PROVIDER=gemini
GEMINI_API_KEY=your_api_key_here

💡 Pro tip: If you want 100% privacy, set LLM_PROVIDER=ollama and run a local model!

5. Install the Git hook

python main.py --install-hook

That's it! Now, every time you commit, the AI will review your code.

💻 Real-World Example

Imagine you write this code:

# auth.py
def get_user(user_id):
    query = f"SELECT * FROM users WHERE id = {user_id}"
    return db.execute(query)

When you commit, the AI immediately flags it:

=== AI CODE REVIEW ===

[CRITICAL] SQL Injection vulnerability detected
File: auth.py, Line 42
Issue: User input directly interpolated into SQL query.
Fix: Use parameterized queries.
CWE-89: Improper Neutralization of Special Elements used in an SQL Command

[WARNING] Hardcoded secret detected
File: config.py, Line 15
Issue: API_KEY = "sk-abc123..."
Fix: Move to environment variable.

This catches the bug before it ever reaches production. 🛑

⚠️ Honest Limitations

Real security engineers respect honesty over hype, so here's what the tool cannot do:

LLM hallucinations: AI can occasionally give false positives. Treat it as a "second pair of eyes," not an absolute truth.
Context window limits: Extremely large diffs might exceed the model's context window.
Offline limitation: Unless you are using a local Ollama model, you need an internet connection.

🔮 What's Next? (Roadmap)

I'm just getting started with this. For v2, I'm planning:

[ ] GitHub Action integration (automatic PR reviews)
[ ] Multi-file context understanding
[ ] Custom rule engine (define your own linting rules)

🤝 Your Turn, dev.to!

If you find this project useful, please give it a Star on GitHub! ⭐

humammoin09-blip / git-diff-reviewer

An automated terminal tool that runs a Git diff before pushing code, uses an LLM to review or roast your code changes, and catches bad practices.

Git Diff Reviewer

A modular, terminal-based CLI tool that inspects local git diffs and sends them to your choice of LLM provider for an automated, high-rigor security and code quality review.

🌟 Key Features

Multi-Provider Support: Seamlessly switch between OpenRouter, Google Gemini, Groq, and local Ollama models.
Flexible Diff Targets: Review staged changes (--staged), unstaged changes (--unstaged), or diff against specific branches/commits (--branch main).
Interactive Mode: Guided terminal prompts for picking diff targets and providers on the fly.
Strict Review Taxonomy: Highlights Critical Bugs, Security Vulnerabilities (OWASP/CWE/Secret leaks), Anti-patterns, and Performance Bottlenecks with actionable Before/After code snippets.
Rich Terminal Rendering: Formatted markdown and colorized panels right in your terminal.
Safe Truncation: Automatically manages large diffs to avoid LLM token context overflow.
Export to Markdown: Save reviews directly to .md files for pull request comments…

View on GitHub

Break it, fuzz it, and if you find a bug, open an issue. I read every single one.

Let me know in the comments what features you'd like to see in v2!

Building an AI Devil's Advocate: A Multi-Agent Debate App with LangGraph & Streamlit #ai #python #opensource #showdev

Humam Moin — Sun, 11 Oct 2026 06:33:17 +0000

Hey devs!
This is my first post on here, and I am sharing what I built

Have you ever wanted an AI that argues with itself? I recently built a project called "AI Devil's Advocate" — a multi-agent debate application that lets two AI agents argue a topic while a Judge AI delivers the final verdict.

But building it came with a major challenges like: API Rate Limits etc.

Here is how I built it, how it works, and how I solved the rate-limit issue using Automatic Fallback.

What is AI Devil's Advocate?

It's an autonomous multi-agent system where:

Agent A (For): Argues in favor of the topic.
Agent B (Against): Argues against the topic.
Judge AI: Listens to both sides and provides a structured verdict.

It's fully built with Python, LangGraph, and Streamlit, supporting multiple free-tier providers like Groq, Google Gemini, and OpenRouter.

Key Features

Multi-Provider Architecture: Switch between Groq, Gemini, and OpenRouter on the fly.
Automatic 429 Fallback (The Magic): If your active provider hits a rate limit or quota exhaustion, the app automatically switches to your next configured provider with zero interruption to the debate.
Polished UI & Animations: Custom CSS, Google Fonts (Inter/Poppins), fade-in animations, and stylized debater cards.
Transcript Exports: Download the entire debate as a styled PDF or Markdown file with 1 click.
Session API Call Counter:** Real-time sidebar counter to monitor your free-tier usage.

Tech Stack & Architecture

Frontend: Streamlit (with custom CSS for animations)
Orchestration: LangGraph (State machine for multi-agent flow)
LLM Factory: Custom FallbackLLMWrapper class that handles provider switching.
Providers: Groq (ultra-low latency), Google Gemini, OpenRouter.
Exports: ReportLab (for PDF generation).

How the Fallback Works
Instead of relying on one API, I built an llm_factory.py that wraps all providers. If the primary LLM throws a 429 Too Many Requests error, the wrapper catches it and immediately routes the prompt to the next available provider in the list. The debate never stops!

Try it Live!

I have deployed it on Streamlit Community Cloud. You can try it right now:

Live Demo Link

Open Source

The project is completely open-source. Feel free to fork it, add new providers, or improve the UI!

GitHub Repository

What I Learned

Building this taught me a lot about:

State Management in LangGraph for multi-agent conversations.
Error Handling in Production LLMs (the 429 fallback is a lifesaver).
UI/UX in Streamlit — you can make it look like a real SaaS product with a bit of custom CSS.

If you have any questions or feedback, drop a comment below! I'm currently exploring more Agentic AI workflows.

And this is my first post, so please let me know if I made any mistakes in writing or anywhere else. Also, if you like the repo, please consider giving it a star..

Happy coding!

DEV Community: Humam Moin