WeXL Forge · Build · Live

Forge Review

Reviews every pull request against your team's standards

Takes
Pull request diff (GitHub)Your standards file, versioned in the repo
Gives
Inline review comments, each citing a rule idOne summary comment per pull requestA pass or fail check on must rulesA recorded trail of overrides
Updated
Draft

The problem

Every team has standards, and most of them are not in the linter. Use the shared error handler. Keep controllers thin. No business logic in the repository layer. Money is never a double. These rules live in a wiki page and in the tech lead’s head, and they reach new joiners one pull request comment at a time.

That is where review time goes. A tech lead reviewing a junior’s pull request spends the first pass on the same comments as last week: wrong layer, missing validation, the logger used the old way. The comments are right, but they are repetitive, they arrive a day after the code was written, and they depend on who happens to review. With AI coding tools in the mix, there is more code to review and it arrives faster, so the same comments are needed more often.

Good looks like this: the team writes its rules down once, in the repo, with an id and a severity; every pull request gets feedback against those rules within minutes, before a senior looks at it; each comment says which rule it is about; the hard rules can block a merge and the soft ones cannot; and when a rule does not fit a particular change, a reviewer can say so and move on, with a record of why.

How it works

Forge Review runs as a GitHub Action on each pull request when it is opened or updated. It reads two things: the diff, and a standards file your team keeps in the repo. Each rule in the file has an id, a description and a severity, must, should or info, and can carry a good and a bad example and the paths it applies to. We start you with a starter file for Spring Boot services and tune it with your tech lead.

It reviews the changed lines against those rules and posts inline comments on the lines it has something to say about. Every comment names the rule id it relies on. A comment that does not cite a real rule from your file is dropped before it is posted, so the bot cannot invent standards. It only comments on lines the pull request changed, and it does not repeat a comment on every push. It also posts one summary comment listing what it found.

Then the gate. By default the review is advisory. Only a breach of a must rule fails the check. If a must failure is wrong for this change, anyone with write access to the repo, other than the pull request’s author, can comment /forge-review override <rule-id> <reason>. The bot checks their permission, lifts the failure for that rule for the rest of the pull request, and records who overrode it and why in the summary comment. If the bot itself fails (the model is down, the diff is too large), the check does not block the merge.

A person then reviews the pull request as usual. The difference is that the routine comments are already there, and the author has often fixed them before the reviewer arrives.

Model access is configurable: OpenAI, Anthropic, Amazon Bedrock or Azure OpenAI, so it can route through a gateway your security team has approved. Automated code review was part of the delivery foundation set up for a leading Southeast Asian bank, delivered with a leading consulting firm, where its job was keeping new squads consistent with the team’s way of working.

Where it gets it wrong

Forge Review is a consistency checker, not a bug-hunter, and it fails in predictable ways.

  • It reads the diff, not the whole system. A change that is fine in isolation can break a rule that only shows up across files, and a change that looks wrong can be fine given code it did not see. It is told to comment only where the rule clearly applies to the changed lines; reviewers still read the whole change.
  • A vague rule gets vague comments. “Write clean code” produces noise. A rule with a clear description and a good and bad example produces useful comments. Tuning the standards file is most of the setup work, and the comments themselves show which rules need rewriting.
  • It will sometimes be wrong about a must. That is why only must rules gate, why overriding takes one comment, and why the override is recorded rather than argued about. A bot that blocks legitimate merges gets switched off, and we would rather it be overridden.
  • It does not find what your rules do not cover. Security flaws, performance problems and logic bugs are outside its job unless your standards file names them. Keep your static analysis and security scanning; Forge Review sits alongside them.

v1 reviews pull requests from branches in the same repository on GitHub. Pull requests from forks, and GitLab or Bitbucket, are not covered yet.

Why not just prompt a chatbot

You can paste a diff into a chatbot and ask for a review. It will comment on whatever it notices, by its own idea of good code, and it will say something different next time. What makes Forge Review useful is the standards file it is held to, the rule id on every comment, the rule that drops anything uncited, the must-only gate and the override trail. Those are fitted to your repo and your team, and they are what you keep.

What you get

  • In your engagement: Forge Review runs on your pull requests from the first sprint, with a standards file written with your tech lead.
  • Under your brand: services firms can run it on their clients’ repositories, starting from their own delivery standards.
  • Built to own: we tune the standards file and the setup to your stack and Git platform, and hand over the source.

See three ways to use an agent.

Run it on your input.

Send us a real pull request diff and your coding standards. We run Forge Review on it and send the output back within one working day, with a note on what we would change for your setup.

Start here

See Forge on your own codebase.

Start a conversationWe'll show the Live agents on a real workflow of yours.