codeapprove

I made a competitor to GitHubs UI for Pull Requests (codeapprove.com)

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.

Some others which are good:

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

You would be surprised! I have encountered the attitude that code reviews are a waste of time. It's not common, and I have never seen this attitude "win" across a team/company but it definitely exists. Some engineers are just overconfident, they believe they could fix everything if everyone would just let them code.

Shameless plug but since you asked ... CodeApprove (https://codeapprove.com) is probably the closest thing you can get to Critique on GitHub. It doesn't help with the Piper/CitC/Code Search parts though, and I agree those were excellent.

I’m biased (I created https://codeapprove.com) but I think GitHub has let code review lag so far behind the rest of the platform. They’ve done a lot of work on project management, CI, discussions, and code authoring but code review has been the same for about 10 years.

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.

I’d recommend CodePeer (formerly GitContext) which is one of the best human code review tools and recently expanded to offer AI review as well.

https://codepeer.com/features/ai

Love the history here! I built a business (CodeApprove) around not liking GitHub's UI for code reviews and I still didn't know most of this.

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?

Love the blog post, it's great to see people actually thinking about how code review should work!

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!

This is 100% true. For some reason GitHub has put very little love into code review even though the Pull Request is probably their most important flow.

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.

Not affiliated with the project but you could use something like OpenRouter to give users a massive list of models to choose from with fairly minimal effort

https://openrouter.ai/

Honestly that’s fair because GitHub is very good and probably too cheap. If they doubled their prices tomorrow I wouldn’t even consider leaving.

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!

I was on a team at Google that used both Critique and GitHub very heavily, so I was able to constantly see the side-by-side and understand the pain engineers faced when doing external code reviews (as a whole, people actually liked working on GitHub).

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.

Shameless but relevant plug: I built CodeApprove (https://codeapprove.com) to bring the best parts of the Critique workflow to GitHub PRs. Obviously there are many things that don't translate (Google doesn't use git, and it has insane CI/CD integration) but CodeApprove gives you the same workflow. You always know which conversations are resolved, which PRs need your attention, etc.

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

Shameless but relevant plug: if you’re a Xoogler and you miss Critique check out CodeApprove (https://codeapprove.com).

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

Actually you can’t comment on lines that haven’t been changed if they’re too far from the changed lines! It’s a weird limitation of GitHubs data model.

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

Bias warning: I created CodeApprove to give GitHub reviews a better UI.

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 does not have that feature because we don't currently do any smart code parsing to understand what would make a file "related". I think Viezly (https://viezly.com/) does the best job at that.

I agree 1000%. I’m the creator of what I believe is a better review interface for GitHub (https://codeapprove.com) but there are also many others:

  * 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 think in the end we should not expect GitHub to provide the best option here. We should expect them to provide a basic option (which they do) and for sophisticated consumers to pay more for a much better option. Everyone should be shopping for code review tools!

Yes yes yes!

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)

This looks excellent! I really like the design and I fully agree with most of the problems you’re trying to solve.

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.

I love seeing projects like this! In general I have always been extremely impressed with the coverage of GitHub's APIs. They're generally well designed, well documented, and available publicly around the same time as a new feature is announced. Which makes it possible to develop alternative UIs like this that aren't complete hacks. Very few other platforms have this type of coverage!

I've used the GitHub APIs on CodeApprove (https://codeapprove.com) to replace the part of GitHub that bothered me the most: Pull Requests.

Shameless plug but if you're looking for an alternative UI for GitHub PRs, you may want to try CodeApprove (https://codeapprove.com)

Frustrations with GitHub's PR performance, limitations, and overall clunky UX are the main reasons people choose to use CodeApprove instead.

Oh do you mean allowing the author to select the order? That's a very cool idea!

Thanks for the feedback! I definitely need to get over hating the sound of my own voice and record a demo video.

Good question, and yes! I'll get a text message as soon as they ask to sign up and I'll have them in the alpha by the end of the day. Anyone who is already in the alpha can invite unlimited teammates.

It's probably ready for public beta ...

Is it too developed if it’s in private alpha?

Anyway … I’ve been working on CodeApprove (https://codeapprove.com) for a while because I think code review is the biggest shortcoming of GitHub.

The idea is to make a code review tool for power users. Just like you have an editor that makes you productive at writing and reading code, you should have a review app that makes you and your team productive at reviewing it.

Or for any Xooglers out there: imagine critique but on GitHub.

Would love feedback on how it’s positioned and if I could improve the value prop!

No plans for Gitlab at the moment, but maybe one day!

Yes that's a real risk! CodeApprove is not (yet) anyone's full time job so it's also an acceptable risk.

However I think the biggest issue with the landscape for code review tools is that 99% of developers use the default system that ships with their VCS. So on most teams, that's GitHub. People should be actively choosing their code review tools just like they choose their VCS, IDE, CI/CD platform, Issue Trackers, etc. It's one of many tools that makes up your SDLC "Stack".

Shameless plug but if you're missing Critique and working on GitHub, try CodeApprove (https://codeapprove.com) which brings as much of the Critique magic to GitHub as possible.

Thanks for the CodeApprove shoutout! If anyone here in the comments wants to try it out, just let me know!