Build Your Own AI Code Reviewer in 15 Minutes: A Grok-4 Powered Streamlit App (That Actually Works)

Because your code deserves a roast from someone smarter than you... and now it can have one, 24/7

Jan 13, 2026

This is a fully functional, Grok-4 powered code review bot that can:

Take any pasted snippet and roast it like a senior engineer on their third coffee
Accept a GitHub URL (repo or single file) and actually read the real files using tool calling
Return surgically precise feedback with copy-pasteable ```diff
Never hallucinate file contents because it fetches them itself

And the best part? It’s 120 lines of clean Python + Streamlit. You can have it running on your machine in literally 3 minutes.

Meet Your New Teammate

Here’s what it looks like when you drop a GitHub file into it:

“Your error handling in secrets.py is dangerously optimistic. Here’s a bulletproof version with proper exception contexts and logging:”
- except TomlDecodeError:
-     raise ValueError(”Invalid TOML”)
+ except TomlDecodeError as e:
+     _logger.error(f”Failed to parse secrets.toml at {path}: {e}”)
+     raise ValueError(f”Invalid TOML in secrets file: {e}”) from e

It finds real bugs. It enforces style. It catches security issues. And it does it instantly.

Why This Feels Like Magic

Most “AI code reviewers” are glorified prompt stuffers.

This one is different because Grok-4 uses real tool calling:

You paste https://github.com/streamlit/streamlit/blob/develop/lib/streamlit/secrets.py
Grok decides “I need to see the actual code”
It calls fetch_github_file(...)
My app serves the real file
Grok continues the review with perfect context

No more “please paste all 15 files.” It just works.

Get It Running in 3 Minutes

Create folder
mkdir grok-review && cd grok-review
Create .env (get your key at https://console.x.ai)
echo “XAI_API_KEY=sk-ant-your-key-here” > .env
Save this as CodeCheck.py (full code below)
Run
pip install streamlit requests python-dotenv
streamlit run CodeCheck.py

That’s it. No Docker. No complicated setup. No hallucinations.

The Full Code (Copy-Paste Ready)

import streamlit as st
import requests
import os
import re
import json
from typing import List, Dict, Any
from dotenv import load_dotenv

load_dotenv()

XAI_API_KEY = os.getenv(”XAI_API_KEY”)
if not XAI_API_KEY:
    st.error(”Create .env with XAI_API_KEY=your-key (get at console.x.ai)”)
    st.stop()

API_URL = “https://api.x.ai/v1/chat/completions”
MODEL = “grok-4”

def fetch_github_file(repo: str, path: str, ref: str = “main”):
    url = f”https://api.github.com/repos/{repo}/contents/{path}”
    params = {”ref”: ref} if ref != “main” else {}
    headers = {”Accept”: “application/vnd.github.v3.raw”}
    try:
        r = requests.get(url, params=params, headers=headers, timeout=15)
        r.raise_for_status()
        return {”status”: “success”, “content”: r.text, “path”: path}
    except Exception as e:
        return {”status”: “failed”, “error”: str(e)}

tools = [{”type”: “function”, “function”: {
    “name”: “fetch_github_file”,
    “description”: “Fetch raw content from a public GitHub repo”,
    “parameters”: {
        “type”: “object”,
        “properties”: {
            “repo”: {”type”: “string”},
            “path”: {”type”: “string”},
            “ref”: {”type”: “string”, “default”: “main”}
        },
        “required”: [”repo”, “path”]
    }
}}]

def grok_stream(messages: List[Dict]):
    payload = {
        “model”: MODEL, “messages”: messages, “temperature”: 0.3,
        “tools”: tools, “tool_choice”: “auto”, “stream”: True
    }
    headers = {”Authorization”: f”Bearer {XAI_API_KEY}”, “Content-Type”: “application/json”}
    try:
        with requests.post(API_URL, json=payload, headers=headers, stream=True, timeout=120) as r:
            r.raise_for_status()
            for line in r.iter_lines():
                if not line: continue
                decoded = line.decode(”utf-8”).strip()
                if not decoded.startswith(”data: “): continue
                if decoded == “data: [DONE]”: break
                json_str = decoded[6:]
                if not json_str.strip(): continue
                try:
                    yield json.loads(json_str)
                except json.JSONDecodeError:
                    continue
    except Exception as e:
        st.error(f”API Error: {e}”)

st.set_page_config(page_title=”Grok Code Reviewer”, page_icon=”🤖”, layout=”wide”)
st.title(”🤖 Grok-4 Code Review Bot”)
st.caption(”Your personal staff engineer — powered by real tool calling”)

tab1, tab2 = st.tabs([”📝 Paste Code”, “🔗 GitHub Link”])

with tab1:
    code = st.text_area(”Paste code”, height=400)
    lang = st.selectbox(”Language”, [”python”,”javascript”,”typescript”,”java”,”go”,”rust”,”cpp”,”c”,”bash”,”sql”,”auto”])

with tab2:
    gh = st.text_input(”GitHub URL or owner/repo”, placeholder=”streamlit/streamlit”)
    col1, col2 = st.columns([3,1])
    with col1: branch = st.text_input(”Branch”, “main”)
    with col2: st.markdown(”<br>”, unsafe_allow_html=True); deep = st.checkbox(”Deep review”)

if st.button(”🚀 Review Code”, type=”primary”):
    if tab1.active and code.strip():
        msgs = [
            {”role”: “system”, “content”: “You are an expert code reviewer. Always provide proper ```diff
            {”role”: “user”, “content”: f”Language: {lang}\n\nCode:\n```\n{code}\n```”}
        ]
    else:
        repo_match = re.search(r”github\.com[/:]([\w\-\.]+/[\w\-\.]+)”, gh) or gh.strip(”/”)
        repo = repo_match.group(1) if hasattr(repo_match, “group”) else repo
        prompt = f”Review https://github.com/{repo}”
        if “/blob/” in gh:
            parts = gh.split(”/blob/”)[1]
            branch, path = (parts.split(”/”,1) if “/” in parts else (parts, “”))
            prompt += f”\nFile: {path} at {branch}”
        if deep: prompt += “\nDeep multi-file architectural review.”
        prompt += “\nUse fetch_github_file tool. Always give ```diff patches.”
        msgs = [{”role”: “system”, “content”: “Senior engineer. Use tools. Provide diff patches.”},
                {”role”: “user”, “content”: prompt}]

    ph = st.empty(); full = “”; tools_used = []

    for chunk in grok_stream(msgs):
        delta = chunk[”choices”][0].get(”delta”, {})
        if delta.get(”tool_calls”):
            for tc in delta[”tool_calls”]:
                if tc[”function”][”name”] == “fetch_github_file”:
                    args = json.loads(tc[”function”][”arguments”])
                    res = fetch_github_file(args.get(”repo”, repo), args[”path”], branch)
                    tools_used.append({”id”: tc[”id”], “result”: res})
        if delta.get(”content”):
            full += delta[”content”]
            ph.markdown(full + “▌”)

    if tools_used:
        msgs.append({”role”: “assistant”, “content”: full, “tool_calls”: [
            {”id”: t[”id”], “type”: “function”, “function”: {
                “name”: “fetch_github_file”,
                “arguments”: json.dumps({”repo”: repo, “path”: t[”result”].get(”path”,”“), “ref”: branch})
            }} for t in tools_used
        ]})
        for t in tools_used:
            msgs.append({”role”: “tool”, “tool_call_id”: t[”id”], “name”: “fetch_github_file”,
                        “content”: json.dumps(t[”result”])})
        ph.empty(); full = “”
        for chunk in grok_stream(msgs):
            if chunk[”choices”][0][”delta”].get(”content”):
                full += chunk[”choices”][0][”delta”][”content”]
                ph.markdown(full + “▌”)
    ph.markdown(full)

st.caption(”Built with Grok-4 + Streamlit • 100% open source • Nov 18, 2025 working version”)

What’s Next?

I’m already cooking:

GitHub Action that auto-comments on every PR
Slack bot integration
Local LLM fallback when you’re offline

Star the repo (I’ll push it tonight):
→ https://github.com/rod-trent/JunkDrawer

Try it. Paste your most embarrassing legacy function. Or drop your startup’s repo URL.

Then come back and tell me what Grok found.

Because honestly? It’s scary how good this is.

Happy coding, — A developer who now has a 24/7 staff+ engineer for the price of a coffee

Discussion about this post

Ready for more?