Slice the Diff: Run a Token-Saving Review Proxy on a Free Server

AI code review burns tokens on every diff. A small proxy that splits the diff, summarizes each hunk, and merges the result can cut the cost by more than half. This post shows how to run that proxy on MonkeyCode's free server with free model tokens, end to end.

MonkeyCode is an open-source platform that ships a free server and free model tokens. That is enough for a solo founder to run a review bot without a monthly bill. Disclosure: This article was prepared as part of MonkeyCode's product outreach.

Why a raw diff is a token trap

A pull request diff contains more than changed lines. There are repeated function signatures, untouched comment blocks, and dozens of context lines that carry zero signal. Feeding that entire blob to a model is like copying a 300-page book to answer a question about one sentence.

A better flow is split, summarize, merge. The proxy reads a diff, breaks it into hunks, asks the model to summarize each hunk in 40-50 words, and then requests a final review brief from those mini-summaries. The total token cost drops because the model never sees the full diff at one time.

This pattern works with any OpenAI-compatible endpoint. MonkeyCode's free tier provides one, so the entire loop runs at zero infrastructure cost.

What the proxy does

The script below accepts a diff file, splits it at hunk headers, and generates two layers of summaries. The first layer extracts local behavior changes. The second layer merges those observations into a single review brief.

The code is deliberately simple. It uses only the standard library and one HTTP call per hunk. Secret keys come from environment variables so they never appear in logs.

#!/usr/bin/env python3
"""Diff summarizer proxy for AI code review."""
import os
import sys
import json
import urllib.request

BASE_URL = os.environ.get("MONKEYCODE_BASE_URL", "https://api.monkeycode.example/v1")
API_KEY = os.environ.get("MONKEYCODE_API_KEY", "")

def call_model(prompt, max_tokens=80):
    payload = {
        "model": "free",  # use the model id from your MonkeyCode dashboard
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": max_tokens
    }
    req = urllib.request.Request(
        BASE_URL.rstrip("/") + "/chat/completions",
        data=json.dumps(payload).encode(),
        headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
        method="POST"
    )
    with urllib.request.urlopen(req, timeout=30) as resp:
        data = json.loads(resp.read().decode())
    return data["choices"][0]["message"]["content"].strip()

def split_diff(diff, max_lines=60):
    lines = diff.splitlines()
    chunks = []
    current = []
    for line in lines:
        current.append(line)
        if len(current) >= max_lines and (line.startswith("@@") or line.startswith("+++")):
            chunks.append("\n".join(current))
            current = []
    if current:
        chunks.append("\n".join(current))
    return chunks

def summarize_hunk(hunk):
    prompt = (
        "You are a code reviewer. Summarize this diff hunk in 50 words or fewer. "
        "Focus on observable behavior changes, not style.\n\n" + hunk
    )
    return call_model(prompt, max_tokens=80)

def final_summary(hunk_summaries):
    combined = "\n".join(f"- {s}" for s in hunk_summaries)
    prompt = (
        "These are summaries of parts of a code change. Write a final code review "
        "brief with risks and suggestions in 150 words.\n\n" + combined
    )
    return call_model(prompt, max_tokens=200)

def main(diff_path):
    with open(diff_path) as f:
        diff = f.read()
    chunks = split_diff(diff)
    summaries = [summarize_hunk(c) for c in chunks]
    brief = final_summary(summaries)
    print(brief)

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("usage: proxy.py <diff-file>")
        sys.exit(1)
    main(sys.argv[1])

Step-by-step deployment

1. Claim the free server and credentials

Log into MonkeyCode's dashboard. Activate the free server option and create a project. From the project settings, copy the base URL and the API key. Store them as MONKEYCODE_BASE_URL and MONKEYCODE_API_KEY.

The exact variable names may differ across versions. Read the project README to confirm. The principle is unchanged: one endpoint, one key, one server.

2. Place the script on the server

Commit proxy.py into a small repository. Then clone it onto MonkeyCode's free server. A typical home directory looks like this:

~/review/proxy.py
~/review/change.diff
~/review/review.md

Test the script manually with a sample diff:

MONKEYCODE_API_KEY=... MONKEYCODE_BASE_URL=... python3 proxy.py change.diff

You should see a short review brief after a few seconds. If the server reports a timeout, raise the timeout argument in call_model or request a lower max_tokens.

3. Schedule regular runs with cron

The free server includes a cron scheduler. A one-line crontab turns the proxy into an automatic reviewer for your repository:

30 9 * * * cd ~/review && git pull --quiet && git diff HEAD~1 > change.diff && MONKEYCODE_API_KEY=... python3 proxy.py change.diff >> review.md

This job runs every morning at 9:30. It fetches the latest changes, compares against the previous commit, and appends a fresh review brief. No CI configuration needed.

4. Read the output

The output is a plain-text brief. It lists the important behavioral changes and a few suggestions. Keep it as a daily log or pipe it into an issue tracker. The format is unopinionated, so adapting it to Slack or email is trivial.

Does it actually save tokens?

Consider a 1,500-line diff with four hunks. A raw call uses roughly 3,000 tokens for input plus 200 for output. The split approach uses four calls at 150 input tokens each, plus one final call of about 400 input tokens. That is roughly 1,000 total input tokens instead of 3,000.

Token savings grow with diff size. Large refactors can be cut to a third of the original cost. The trade-off is latency: several sequential calls take longer than one big call. For an overnight or morning job, that trade is acceptable.

Limitations

The proxy is not a replacement for human review. It summarizes, but it does not execute code or verify logic against tests. The free model tier also has rate limits and may refuse very long or highly specialized content. Read the official documentation before placing this in a production pipeline.

The script splits only at hunk headers. A hunk with 200 changed lines will still be sent whole. For very large hunks, add a character-based splitter that respects string literals and comments. The current version favors simplicity over completeness.

Who should not use this approach

Teams with strict compliance requirements should not route proprietary code through any free model service. Projects that need real-time, interactive review will find the cron latency frustrating. And anyone expecting bulletproof analysis, not a signal, should look elsewhere.

For a solo developer or an unfunded founder, this pattern is a cheap way to get a second opinion on every commit. The server stays free, the token bill stays near zero, and the output stays useful as long as you treat it as a suggestion rather than a judge.