Graphite Blog

Our team switched over to Graphite [1] 8 months ago now. Graphite involves a lot of "restacking" (i.e., rebasing for every commit/branch in a "stack"). No one on our team had used rebasing extensively before this, but it's hard to go back. Similar to the article, the benefits we see are: - Fast iteration with `gt m` (`git commit --amend`) and `gt s` (`git push --force`) - Using `gt restack` (`git rebase` on each parent commit) helps make merge conflicts more transparent in what happened - Commit histories are much more legible I highly recommend giving it a go. [1] https://graphite.dev/

This seems like a great tool. I’m personally hooked on the https://graphite.dev CLI and would just like to mention it for comparison.

Graphite (https://graphite.dev/) has been a good tool at our startup to manage stacked PRs, I recommend checking them out.

Graphite |Senior Software Engineers| New York, NY in our Soho Headquarters | https://graphite.dev We’re building Graphite to help high-performing engineering teams run faster, cleaner code reviews. Our product is already used by some of the world’s best developers, and we’re just getting started! We are also thrilled to share that Graphite is joining Cursor! With Cursor, we’ll bring together the best-in-class tools for creating, reviewing, and merging code in the age of AI. We're hiring experienced engineers across the stack, are are looking for people who: -Care deeply about code quality, system design, and scaling software responsibly -Have a strong product sense and enjoy collaborating closely with design & product teams -Have experience with AI-driven workflows, prompt engineering, or interest in developer tooling is a plus -Are product-driven and quality-obsessed; we ship thoughtfully and often The hiring process: quick intro call, 2 technical interviews, & an onsite interview, followed by offer! If you are someone who wants to work on meaningful problems, values clean code and thoughtful systems, & loves building tools for other engineers, we'd love to chat with you! You can apply directly on our careers page(https://graphite.dev/careers#positions) or email [email protected] with the subject title: "Thank you for stacking with us) with a copy of your CV. Recruiters: appreciate your hustle, but we’re only hiring through direct applications.

Graphite | Mid-level & Senior Software Engineers| New York, NY in our Soho Headquarters | https://graphite.dev We’re building Graphite to help high-performing engineering teams run faster, cleaner code reviews. Our product is already used by some of the world’s best developers, and we’re just getting started! We're hiring experienced engineers across the stack, are are looking for people who: -Care deeply about code quality, system design, and scaling software responsibly -Have a strong product sense and enjoy collaborating closely with design & product teams -Have experience with AI-driven workflows, prompt engineering, or interest in developer tooling is a plus -Are product-driven and quality-obsessed; we ship thoughtfully and often We've recently raised a $52m Series B by Accel, A16z, & others, and have big goals this year. The hiring process: quick intro call, 2 technical interviews, & an onsite interview, followed by offer! If you are someone who wants to work on meaningful problems, values clean code and thoughtful systems, & loves building tools for other engineers, we'd love to chat with you! You can apply directly on our careers page(https://graphite.dev/careers#positions) or email [email protected] with the subject title: "Thank you for stacking with us) with a copy of your CV. Recruiters: appreciate your hustle, but we’re only hiring through direct applications.

No, paying for GH doesn't make the code review experience any better. It's identical across public/cloud/enterprise GH. I do not know if GitLab does anything different; I've never used it in anger. I'd bet $10 the answer is "no, it's basically just the same as GitHub", though. If you want a service that adds stacking on top of GitHub, my conclusion after some research is that https://graphite.dev/ is the best option. We did consider it, but it couldn't work in my last job for "reasons" (see my other replies in this thread) but if you've got a shop of Git users and just want to throw money at the problem, I think it's the best choice. GerritHub is also a possibility, they employ many of the Gerrit devs and know what they're doing, but holy shit the corporate options are expensive out of the gate. It's like $20k/yr minimum regardless of size or number of users. Honestly, Graphite is cheap as hell considering how much more productive your engineers can be with a good review tool. Gerrit was basically night and day for us. It's not "oh, it pays for itself really quickly in a few days!" You'd probably pay off the monthly cost in less than an hour of actual code review. And you don't even have to opt most of your engineers in; you can trial it where 90% of them use GH and only a subset use graphite and pay.

Agreed with a lot, but for many companies I think cleaning up git history is more effectively accomplished by cleaning up PRs than actually trying to clean up the commits themselves that developers write. "Good commits" are one of those things that benefit the whole, but no individual developer is incentivized to do. Because of that, it's easier to enforce at code review (rather than hope developers just do it). Many companies do this by squashing changes, so a developers' commits and the commits on trunk are decoupled. I think the best way to make changes (and therefore commits on trunk) understandable is to split them up into series of dependent changes; something supported by the code review tooling used at places like FB / Uber / Google, but not super well in GitHub... Which leads to large PRs with a lot of unrelated fixes. Disclaimer: I work at a company trying to bring that dependent change / stacked diff workflow to git and GitHub (https://graphite.dev).

> large monorepo features (allow user to view a slice of a repo) I am reminded of this discussion between fb devs and git devs from 13 yrs ago: https://public-inbox.org/git/CB5074CF.3AD7A%[email protected]/t… git has definitely made improvements since that thread, e.g.: https://graphite.dev/guides/git-monorepo#tools-and-strategies-for-effi… but it could still be better for the truly gargantuan of code bases. Might not be worth it? Idk. Maybe with llm generated code churn, suddenly it becomes worth it? haha.

I’ve had a lot of success using https://graphite.dev/. Been pretty easy to pick up and slots right into our usual GitHub workflow. I end up using the vscode extension to manage it. Anyone have opinions how jujutsu compares?

I created CodeApprove (https://codeapprove.com) because of my own frustrations with GitHub's code review UI and my experience with far superior tooling inside Google. In the last ~5 years there has been a huge increase in the number of alternative code review tools for GitHub. Some of my favorites (besides CodeApprove, of course): - Graphite (https://graphite.dev) - Reviewable (https://reviewable.io) - CodePeer (https://codepeer.com/) - Codelantis (https://www.codelantis.com/) All of them have many of the things you are looking for!

https://graphite.dev/ provides a way to stack PRs, it's been discussed on HN in the past (e.g. https://news.ycombinator.com/item?id=30681308).

Surprised no one has mentioned https://graphite.dev/ yet. Our team uses it for stacked PRs, and it works really well.

Not to be confused with: https://graphiteapp.org/ (Time Series DB) https://graphite.dev/ (Code review suite)

Wow, what a great article/read! Edit: saw this link to another article, it's a great read as well. https://graphite.dev/blog/why-facebook-doesnt-use-git

I think Git itself is probably too entrenched to be displaced by now, but I recently came across Graphite (https://graphite.dev/) and, while it’s all still Git under the hood, it abstracts away many of the common pain points (stacking PRs, rebasing) and has nice integrations with GitHub and VS Code.

What do you think Gerrit is missing compared to Critique? Graphite[0] is also similar in that space(code review platform built on GitHub), the CLI could use some work but combined with the web UI it scratches that same itch that Critique did for me [0] https://graphite.dev/

I think that this page gives a decent overview of what the tool aims to accomplish: https://graphite.dev/docs/how-stacking-works This page covers some of the more advanced functionality: https://graphite.dev/docs/manage-stacks Either way, I hope you like it! I've tried many other tools that aim to implement stacked diffs for GitHub PRs, and Graphite is _by far_ the best. They have their own Web UI but I skip that completely and just use their CLI + GH's UI.

It’s also now a Code Review platform (https://graphite.dev/) but your example was my first thought as well.

Graphite | Software Engineer, Frontend Engineer, Product Designer, Product Manager, Data Scientist | Onsite, New York NY https://graphite.dev Graphite is modern code review for fast-moving teams - we help engineers write and review smaller pull requests, stay unblocked, and ship faster. We’re a small-but-mighty team of 15 based in Manhattan in the heart of Soho, with a passionate and rapidly growing group of users (7x growth in 2022 so far) at top engineering orgs like Datadog, Bolt, Brex, Ramp, and Snowflake. We just closed our $20m Series A (featured in TechCrunch) led by Peter Levine at Andreessen Horowitz (who led GitHub's Series A), with participation from folks like Tom Preston-Werner (founder of GitHub), Sam Lambert (Planetscale CEO & ex-GitHub CTO), Sebastian Markbåge (creator of React), and many more. Apply: https://graphite.dev/careers

https://graphite.dev is also aiming to provide a FB-like workflow including stacks.

Trunk-based development is still in use at large companies. Usually they use something like Gerrit or Phabricator. You could try tools like https://graphite.dev/ or https://reviewable.io/, or Meta's Sapling + ReviewStack.

We switched to using https://graphite.dev/ after yet-another huge epic that caused a mess of PRs and one PR that touched 100+ files and included dozens of semi-related changed. It's been a blessing so far.

For code review: At my previous company we used Phacility/Phabricator but unfortunately it's no longer maintained[1]. Both my previous and current companies have since switched to using Graphite[2], which has delivered a pretty compelling stacked PR and code review experience. [1] https://admin.phacility.com/phame/post/view/11/phacility_is_winding_do… [2] https://graphite.dev/

https://graphite.dev/ > Join the waitlist :-( Since you seem to be in the beta, you may want to let them know their Homebrew tap is pointing to the wrong GH org: https://github.com/withgraphite/homebrew-tap/blob/master/Formula/graph…

Try out Graphite! Half of us are ex-FB, so we get it. https://graphite.dev/

Neither GitHub nor GitLab quite hit the mark for me with regards to code review. Phabricator (RIP) was close IMO, with first class support for (1) seeing comments and code on one view and (2) supporting stacks which prevent mega changes. I've been working with some peers on a better code review tool since hearing about Phabricator shutting down: https://graphite.dev/ It syncs all data to GitHub while offering things like a review queue, gif reactions, stacked diffs, etc - all inspired from Phabricator.

Generally, most things jj does can be done in Git, it's just much more pleasant / seamless / consistent in jj - maybe with the exception of the "Working on Two Things at the Same Time" pattern[0], that one might be really hard to achieve in Git. > but does it work as a front-end tool over git/other VCS? citing from the article > Before we dive in, one last thing you should take note of, is that most people use jj with its Git backend. You can use jj with your existing Git repos and reap its benefits in a way that is completely transparent to others you’re collaborating with. Effectively, you can treat it like a Git frontend. > I don't get it. What does make rebase hard? It's hard when you work on a set of stacked PRs and make frequent changes to arbitrary PRs in that stack, because every time you make a change, you have to manually rebase and push all of the other PRs. There's SaaS's specifically built and used for solving this problem in Git[1]. Maybe hard is the wrong word, it's just annoying and tedious. jj makes this completely seamless, as shown in the article[2]. [0]: https://kubamartin.com/posts/introduction-to-the-jujutsu-vcs/#pattern-… [1]: https://graphite.dev/ [2]: https://kubamartin.com/posts/introduction-to-the-jujutsu-vcs/#pattern-…

The video mostly just reads the following article out loud: https://graphite.dev/blog/why-facebook-doesnt-use-git - go read that instead. It's also more balanced and doesn't attempt at simplistic explanations of "monorepo - good" and other topics. Also, this video makes it seem as if Facebook, and its wants and contributions are the center of everything. Open source developers don't need to start working whenever any user messages them on performance issues, especially if it's an outlier in the grand scheme of things. EDIT: Reading the article more thoroughly: > What they [Facebook's investigating team on which source control to use] found was a system [i.e, Mercurial] that was easy to extend and a community of maintainers who were impressively welcoming to aggressive changes by the Facebook team. So Mercurial, as a smaller and more nimble developer group, was just more open to substantial outside changes to its code base.

Along what axis do you want the VCS to be "better" than git? For example, git's cli user interface is monstrous (yes, I know, you personally have 800 cli commands memorized and get them all right every time, that doesn't make it "good"). From the outset, the maintainers of git basically decided "it's too much work to make all the cli flags behave and interact consistently" so they didn't. This allowed git to grow fast, at the cost of the cli user experience. That said, git is big enough that multiple companies have come along and "solved" the git UI problem. None of these aftermarket UI layers are perfect, but there are enough of them and they are different enough that you can probably find one that is good enough for you, along whatever axis you personally dislike the git UI (examples include [0], [1], [2], which tackle very different user workflow problems). [0] https://git-fork.com/ [1] https://graphite.dev/ [2] https://news.ycombinator.com/item?id=7565885

I think this is what https://graphite.dev is trying to do.