Offside

Opening VAR Screen
General code review screen
A users accumulated cards
User push gets blocked
Raised issue is overturned after discussion with user
User receives red card (severe mistake)
Multi-language/skill support
Appeal GIF

Inspiration

Engineers, we can be honest. Code review is where excitement goes to die. At the same time, GenAI is making it easier than ever to generate and push code to critical codebases, especially without even understanding what it does.

Making Offside, we wanted to help interns and newer developers slow down and ensure they're pushing strong code. Instead of throwing a wall of feedback which they're unlikely to read (and more likely to paste into another AI to fix it for them), we turned code review into a game that teaches them about the risks of change.

So our question was: What if reviewing code felt less like a burden and more like a soccer match?

What it does

Offside is a Git pre-push referee that helps developers push code they actually understand. When a user runs git push and we spot something suspicious, it pauses the push and sends the play to VAR.

The developer sees the code replayed line by line. Offside explains the problem in plain language, then gives the code a card and deducts HP. Intern mode provides more teaching and only gives red cards for serious problems.

Think the referee got it wrong? Contest the call. Developers have 60 seconds to either type or speak out their justification, and then Offside investigates their argument, rechecks the codebase, and may overturn the decision.

Each finding includes a suggested fix, so developers have a clear next step. If the issues are resolved, the referee signals “play on,” and the push continues: all within the Git workflow they already use.

How we built it

The flow starts inside Git. We wrote a Python CLI that installs a pre-push hook into a repository. When someone runs git push, the hook pauses the command. The CLI finds the exact commits being pushed and creates a diff for Offside to review.

That diff is sent to a FastAPI backend. The backend first runs a quick review to look for risky changes. If a finding needs more proof, Offside searches the local repository for related code and checks the Git history. It then sends that added context through a deeper review before making the final call. We use the OpenAI API for these reviews. We also built a rule based fallback so the full flow still works without an API key.

At the same time, the CLI opens a React page built with TypeScript and Vite. The backend sends live updates to the page using Server-Sent Events. The interface turns each finding into a VAR replay, then shows the evidence behind the decision. The severity decides whether the code receives a yellow or red card and how much HP the developer loses.

If the developer disagrees, they can contest the call. The backend uses their argument to search for new evidence and runs a second review. Once every finding is handled, the backend returns its decision to the waiting Git process. An approved review lets the push continue. A serious unresolved issue blocks it.

Challenges we ran into

Figuring out the exact code included in a push was harder than expected. New branches and empty pushes behave differently from normal updates.
We needed to pause git push without making it feel frozen. The CLI had to wait for the browser review while still handling timeouts safely.
Keeping the CLI and browser on the same review state took careful work. We used a FastAPI backend as the single source of truth.
AI code reviews can sound confident without enough proof. We built a second review stage that checks repository context and Git history before making certain calls.
Appeals added another layer of complexity. Offside needed to understand the developer’s argument, gather new evidence, then decide whether to overturn the original call.
We spent a lot of time balancing the soccer theme with clear technical feedback. The experience had to be funny without hiding the real problem in the code.

Accomplishments that we're proud of

We built the full flow from git push to the final verdict. It works without requiring the developer to copy code into another tool.
Offside can stop a push, open the VAR review automatically, then return its decision to the same Git process.
Our findings include evidence from the repository instead of relying only on a raw diff.
Developers can challenge a finding. Offside performs a deeper investigation instead of repeating the first answer.
The rule-based fallback keeps the full demo working even when the OpenAI API is unavailable.
We turned a normal code review into an interactive experience with cards, HP, replays and roasts.
We added different review levels so interns can receive more explanation while experienced developers can get shorter feedback.

What we learned

Git hooks are simple to install, but handling real push behaviour takes careful work.
A code reviewer should investigate before making a strong claim. A confident answer is not the same as a correct one.
Fast AI checks work well for finding possible issues. A slower second pass is better when the decision depends on context.
Server-Sent Events are a simple way to keep the browser updated while a review is running.
Good developer tools need an escape path. Timeouts and fail-open behaviour prevent Offside from trapping someone inside a broken push.
Humour can make a technical tool more memorable, but the feedback still needs to be useful.