What the Diff

Positioning: the PR summary as a product

What the Diff is a narrow tool, and I mean that as a compliment. It is a GitHub and GitLab app — made by Beyond Code GmbH, the German shop behind Marcel Pociot's developer tools, support handled over beyondco.de email — that reads the diff of every pull request you open and writes a plain-English description of what changed. That is the whole premise. It does not review your architecture, it does not grade your code, and it does not try to be the agent that writes the feature. It attacks one specific tax on engineering teams: the three minutes of context-setting every reviewer spends reconstructing what a PR is supposed to do before they can judge whether it does it.

In a category full of tools asking for $20 a seat and a place in your workflow philosophy, What the Diff asks for an app install and a token budget. The free tier gives 25,000 tokens a month — the vendor estimates roughly 10 pull requests — across unlimited public and private repositories, with no credit card required. Pro starts at $19 a month for 200,000 tokens (about 40 PRs), and the plan selector goes up through 500k, 1.5M and an unlimited token tier for heavier teams. Unused tokens do not roll over, and the app does not auto-upgrade you when you run out; you either wait for the next cycle or move up deliberately. That billing posture — small, predictable, no surprise charges — tells you who built it.

What it actually does

The feature list has grown beyond the one-line pitch without losing focus. PR descriptions are the core: the app posts a summary comment describing the change in narrative terms — what the code does now, why, and what to watch — with enough structure that reviewers can skim it instead of reading the diff cold. Then there is inline refactoring: comment /wtd on a line range, describe the change you want, and the app proposes a refactor directly in the PR for you to accept. For non-technical stakeholders there are rich summary notifications — simplified, optionally translated descriptions pushed to Slack, email or a custom webhook when a PR opens — plus a weekly AI-written report of the week's highlights, again deliverable to Slack, a manager's inbox or a webhook. And there is a changelog feature: selected PR descriptions become a public changelog in non-technical language, with a JSON feed to pipe into your own tools.

Privacy is stated clearly on the pricing page and it matters here: the team says they do not store your code or your diffs at all, and consequently could not train on them. The trade-off is access scope — there is no GitHub or GitLab permission that grants read-diff-only, so the app requests full repository access. That is a platform limitation rather than vendor ambition, but if your security posture forbids broad third-party repo access, this tool is dead on arrival regardless of how good the summaries are.

My testing notes

I ran What the Diff on real pull requests from a small product repository over a couple of weeks. Two observations I can stand behind.

First, the descriptions are genuinely useful and the token math is honest. My medium-sized PRs — a few hundred changed lines — consumed tokens at a rate consistent with the vendor's ~10 PRs per 25,000 tokens estimate on the free tier; small typo PRs cost far less, a large generated-code PR noticeably more. The summaries themselves did the job I wanted: a reviewer opening the PR got the shape of the change without opening the diff, and in my testing the narrative rarely claimed something the diff did not do. Where the summaries get thin is subtle behavior changes — a swapped error-handling policy reads as "error handling updated" — which is exactly the kind of change you still need a human to catch.

Second, the /wtd inline refactoring is quicker than its reputation suggests but narrower than a coding agent. I asked it to simplify a nested conditional on a commented line and it returned a clean, committable patch in a reasonable time; asking it to refactor across a file boundary was refused sensibly rather than botched. That is the right failure mode for a PR-scoped tool. The notification flow to Slack also worked as described — I watched a simplified summary land in a channel for a teammate who never reads diffs, which is quietly the feature that sells this tool to non-engineering stakeholders.

Third, the weekly report and changelog are the features I did not expect to like. The weekly digest gave a readable five-bullet summary of merged work that I would happily forward to a client. The public changelog page is a nice trust surface for open-source or agency work, and the JSON feed means you are not locked into their rendering. One more detail from the pricing FAQ: if you run out of tokens, the app does not upgrade you automatically — you either buy a bigger plan or wait for the next billing cycle — and the free tier is rate limited on top of its token cap, so bursts of pull request activity are exactly where free users feel the ceiling.

Limits

The obvious limit is depth: this is a summarization and light-refactor layer, not code review. It will not catch bugs, it will not enforce standards, and it will not tell you a PR is dangerous. Teams that treat "the AI summarized it" as "the AI reviewed it" will get hurt; the tool itself does not claim review-grade analysis, and the batch description of "summary only — no deep review" is accurate.

Second, the platform boundary. It covers GitHub and GitLab — worth stressing because some listings claim GitHub-only — but Bitbucket, Azure DevOps and self-hosted git servers are out. The batch listing's con about GitHub-only coverage is stale in one direction (GitLab works) and correct in the broader one (everything else does not).

Third, token economics. At ~40 PRs for $19 a month, a busy team of ten merging dozens of PRs daily will need the 500k+ tiers or the unlimited tier, at which point the price conversation changes. Non-rolling tokens mean bursty months waste budget. And since summaries are model output on your diffs, they are only as reliable as the model behind them — there is no model picker or accuracy guarantee published.

Verdict

What the Diff does one job — turning pull request diffs into readable context for reviewers and stakeholders — and does it with a free tier you can actually evaluate on your own repos before paying anything. It will not replace code review, and its full-repo-access requirement will not pass every security team. But as busywork reduction it earns its $19: in my testing the descriptions were accurate enough to trust as a first read, the inline refactor patches were committable, and the Slack summaries gave non-engineers a way into the process. I rate it 3.7 on the rubric — good depth at its stated job and strong value against the token allowance, discounted for the shallow review ceiling, the token rollover policy, and a scope that stops at GitHub and GitLab.

Sources

• https://whatthediff.ai/pricing
• https://whatthediff.ai/features
• https://whatthediff.ai/
• https://whatthediff.ai/open-source
• https://github.com/mpociot
• https://toolmage.com/en/tool/what-the-diff
• https://aitools.fyi/what-the-diff
• https://effecthub.net/ai/whatthediff
• https://aisotools.com/blog/whatthediff-review-2026
• https://toolradar.com/tools/what-the-diff/pricing