It’s built in Vue. My first 5 or 6 attempts at writing the diff viewer were very slow when things got big. I optimized this a lot and now I’m pretty proud of how snappy it is.

I’m not saying this as a plug (this is mostly a passion project not a big business) but to say that it’s possible to make a snappy GitHub PR UI using a frontend framework on top of GitHub’s own APIs. You just have to care. It’s not clear that they care.

  * Reviewable
  * Codestream (formerly GitContext)
  * Codelantis
  * CodeApprove (biased, obviously)

Tools like Graphite, CodePeer, Codelantis (and of course CodeApprove) make it so much easier to have a meaningful discussion on a PR. Making sure every thread comes to resolution, knowing whose turn it is, having a fast way to navigate between code and comments, etc. The FAANG companies all have this kind of thing built in house because good code review is a key part of building high quality large software projects.

https://codepeer.com/features/ai

I will never understand why GitHub has not invested as much in code review as they have in the rest of their platform. For their paying customers it has to be the number one part of their platform in terms of time-on-page.

But one thing they did well was open basically every part of the review experience to GitHub apps via their APIs. So tools like CodeApprove, Reviewable, Graphite, GitContext, etc can build better experiences over the top and give GitHub users more choice.

I still don't know why most programmers just accept the default here. GitHub made an IDE (Atom) but we don't all just use it because they said so. Why do most of us use their code review UI just because it's there?

I've used four different code review systems extensively, all with different strengths and weaknesses: Critique (Google internal), Gerrit (at Google, but same as external), GitHub (duh), and CodeApprove (the one I built).

Critique was far and away the best, but it only works because it's perfectly fit to Google's monorepo and the custom VCS they've built as well as all of their custom lint/test tooling. I designed CodeApprove to bring as much of that as I could to GitHub, but it will never really be close.

Gerrit was the second best in terms of the reviewer experience ... but as an author I always hated it. It just seemed to be so author-hostile. There were more wrong ways to do something than right ways. And the UI is not exactly beautiful.

GitHub is extremely author friendly, it works how we think. You write code, you get feedback, you write more code, etc. If you squash and merge at the end of a PR you don't have the history problems the author mentioned. It's not very reviewer or team friendly though. Incremental diffs are not highlighted. Diffs and conversation are in different tabs. Force pushes and rebases destroy history. Comments are lost as "outdated". You can't comment on files outside the diff window. Large files are hidden by default, etc etc. They clearly don't care about this too much and maybe they know something I don't.

In the end, the thing I find most frustrating is how many teams just accept whatever code review tool is built in to their VCS platform. That would be like using whatever IDE shipped with your laptop! There are so many better options out there today. My favorites (besides CodeApprove) are GitContext, Reviewable, and Graphite but I can name half a dozen other excellent choices. Don't accept the defaults!

The good news is that many people have built better code review interfaces on top of GitHub. My favorites:

- CodeApprove (I created it, so yeah I like it)

- Graphite

- Reviewable

- GitContext

Check them out! You’d be surprised how much better they are and how quick they are to set up.

https://openrouter.ai/

What would you pay for CodeApprove? Also if you email me I’m happy to set you up with a 6-month free trial with no credit card required. Maybe you’ll like it more than you think!

After I left I created CodeApprove (https://codeapprove.com) to bring a lot of Google's best code review practices to GitHub. It doesn't give you everything Critique did, but I think it brings the same speed, clarity, and focus in a way that's still compatible with the rest of your GitHub workflow.

Feel free to reach out via email if you're curious.

CodeApprove was built to make GitHub PRs a lot more appealing to those who miss the Critique workflow (among others audiences).

(source: that’s one of the features that people like most about the review tool I created, CodeApprove)

GitHub PR review UI is … fine. But it has very little depth. Unlike an IDE it’s hard to grow into a power user of it. It seems to be optimized for simple reviews with 1-2 rounds of a few comments each.

When you do dozens of code reviews every week you want something more. You want something snappy and dense with keyboard shortcuts. You want something that draws your attention to where it’s needed and something that helps you ensure all your conversations reach resolution.

So there’s a lot of room for improvement and GitHub hasn’t shown much interest in improving this area. So 3p UIs are stepping in (Graphite, CodeApprove, Reviewable, etc)

  * CodeApprove (codeapprove.com)
  * Graphite (graphite.dev)
  * Reviewable (reviewable.io)
  * Axolo (axolo.co)
  * Viezly (viezly.com)
  * Mergeboard (mergeboard.com)
  * Codestream (codestream.com)
  * Pullpo (pullpo.io)
  * ReviewPad (reviewpad.com)
  * Planar (useplanar.com)
  * Visibly (visibly.dev)
  * Codelantis (codelantis.com)

I am biased because I make/sell an alternative UI for GitHub code review (https://codeapprove.com) but I think most of us can agree that GitHub's tools for code review are not nearly as good as they could be.

We all spend time picking our VCS, our IDE, and our CI/CD systems. But for code review we just accept what comes out of the box!

There are so many good tools out there to level up your code review! Here are a few of my favorites:

  * CodeApprove (codeapprove.com)
  * Graphite (graphite.dev)
  * Reviewable (reviewable.io)
  * Axolo (axolo.co)
  * Viezly (viezly.com)
  * Mergeboard (mergeboard.com)
  * Codestream (codestream.com)
  * Pullpo (pullpo.io)
  * ReviewPad (reviewpad.com)
  * Planar (useplanar.com)
  * Visibly (visibly.dev)
  * Codelantis (codelantis.com)

The biggest issue with code review tools is that we’re mostly all using the same one (GitHub) with no customization. We should care as much about our choice here as we do about choosing our editors/IDEs.

I’m in the same space (CodeApprove.com) and if you ever want to chat my email is in my bio.