> Once you have the power to do a bunch of small self-contained changes, you want PRs to consist of one or two commits. You want to build on previous changes without needing to wait for them to be reviewed. Lubeno helps you to do exactly this.<p>Why would I want to build on changes that haven't been reviewed and accepted? That's a good way to waste my time having to redo something because the foundation it was based on was flawed and got rejected later.<p>There's a reason git and most accepted development workflows are <i>linear</i>.
Because those changes might depend on those other changes. Git merges <i>aren't</i> linear. They're branched. And PR reviews are meant to just examine the merge of 1 branch back into master. They're not really meant to review multiple steps along the same branch to make it easier to review.<p>There are so many times where I want to create 3-4 Merge requests that all build on each other along the same branch instead of creating one giant MR but the UI for reviewing them doesn't really work that way.
I do that a whole lot because most of the time I know the foundation will be accepted mostly as-is, maybe with small tweaks but not major changes.<p>So I branch of a previous PR instead of development when the changes are related, and continue development, and rebase after the previous PR has been merged.<p>Usually this leads to <i>less</i> rework and fewer merge conflicts.<p>Very occasionally it means having to rework subsequent work because the approach was actually wrong, but I'll take that over the hassle of continuing to work from a base I <i>know</i> is already outdated.
You can just start a new branch in parallel if you don't need to build on top of the foundation. But if you are happy with the foundation and the next feature requires it, you can also continue working on something else. Jujutsu's automatic change propagation to children can also help if you need to adjust the foundation. For me work is mostly continues, like a flow.
If you’re getting to the point where you’re submitting PRs if you don’t know whether the foundation of the change is flawed, you have more pressing issues than wasting time in code review fixes.
There's only a limited amount of context and decisions that can be effectively communicated informally without looking at the code. Sometimes it is required that people look at the actual suggested implementation, and when doing so they might spot fundamental issues that had not been found beforehand. The conventional format for doing such a review is a PR.
Often it's very likely that previous ones won't need to change significantly, in which case disposing of having the full context while waiting for that review ends up slowing you down a lot. In those cases, often the main cause of extra busywork is Git administration, having to manually rebase sub-branches, and then losing in-progress reviews on those PRs as well.
Anecdata, but I don’t find myself making major changes to code during review often. That speaks to a deeper problem (miscommunication of requirements, author skill, overly pedantic reviewers, etc).<p>Also, I don’t have time to wait around for a review to work on other parts of the same codebase.
I appreciate you recognize there is still a reason for grouping commits into mergeable units (PRs). Some go too far and only want every commit to be independent.<p>I also appreciate the ordering. In my projects, we put an extra focus on tests by having having a commit that adds new tests to reproduce the bad behavior so when you diff the tests with the fix commit, you get a visual of how things changed.<p>I also find that the order can be PR specific. I wonder about allowing the contributor or reviewrs reorder on per-PR basis.<p>There are also times we have a lot of test or doc changes. I wonder about grouping items to jump between or collapsing to more easily navigate around than opening and browsing a file picker.
There’s an interesting nugget of an idea in this ad. But the current implementation leaves a lot to be desired. What I want out of the PR interface is to be able to ask an agent questions and get back supported answers and to be able to easily see the changes live in a system so I can test them. That requires solving a huge problem of iterative deployments but if you could do that the value of stacked PRs would be immense. If someone doesn’t do this then PRs will just be abandoned.
There's a much more interesting idea that I'm waiting for somebody to do, which is just have AI break down a PR into digestible chunks for me. Stacked PRs are a nice idea but they require the developer to follow the pattern. I'd rather be able to get a big 50+ file PR, and have it be broken down into bite size areas I can review and check along as I go.<p>This would be especially helpful for mobile, where reading a traditional diff is basically impossible.
I work in between two teams that would prefer no code review except for by pair programming (militantly arguing that this is the only true trunk based development, those small PRs are something else) and a team that every individual wants to own the dev cycle end to end. So its either pushes to main youre forced to catch up on that you had no alerts or knowledge of, or +6000 -500 diff PRs with way too many features and no story to tell in the commits.<p>Maybe this tool would help, but nothing in this pitch convinces me.
Jujutsu is interesting in that it appeals both to Git enthusiasts, and people who strongly dislike Git's UX. It's great to see it spurring more innovation in the ecosystem around it.<p>Though if it can just make stacked PRs widespread, I'd already be very happy.
The platform this is an ad for looks to be very bare-bones, but I’m still very glad to see a new entry in the code forge space focusing on stacked PRs since Graphite went all-in on clanker review. Extremely keen to see what will come out of ERSC [0]<p>[0] <a href="https://ersc.io/" rel="nofollow">https://ersc.io/</a>
Just to be clear about it, we’re not “the stacked diffs company,” that is, we consider stacked diffs table stakes for good code review, not the entire point and focus of the product.<p>That said, we haven’t talked a ton publicly about what exactly we’re building yet, because we’re very focused on building it. But if you or anyone else is dealing with pain around source control management, I’d love to hear about it: steve@ersc.io
On my first load of this page, it took 4.85 seconds to get meaningful content and the whole page took 8.09s. The vast majority of the delay seems to be from assets like the PNG images and the fonts, which don't seem to be on a CDN. I am located in Tokyo, Japan, with a 1Gbps symmetric connection, so while I am regionally quite distant from the site, I assume, I still think there are ample CDNs available that would speed this up.
Lucky you. Blog.js fails for me with a TypeError and I'm disinclined to debug someone else's javascript on a whim, so I don't get to see any of the content at all.<p>To the OP: JS is for enhancements. If you are using it in such a way that it becomes a potential blocker for all of the content then you are not going to reach the audience that you otherwise would. If you are on somebody else's platform/framework then by all means pass this up the chain.
Mobile is particularly bad<p><a href="https://pagespeed.web.dev/analysis/https-lubeno-dev-blog-reinventing-the-pull-request/12a9907gmb?form_factor=mobile" rel="nofollow">https://pagespeed.web.dev/analysis/https-lubeno-dev-blog-rei...</a>
Sorry about that! Performance is really important to me, I just didn't get around to configuring CDN caching and optimizing the assets. All the HN traffic hitting our server also didn't help.
I'd love to see an example PR on lubeno vs github. That might show the comparison a bit better.
Let's forget that this post is an ad. I feel like there is a use for LLMs that could help us do stacked PRs better.<p>Right now there are effectively three ways to do a PR:<p>- a bunch of small commits, some of them related to the feature, some fixes, some mixing both -> a PR with 'n' commits -> they don't really make sense as atomic commits, you have to review the entire PR to make the sense of it<p>- a squashed PR<p>- some uber principled reorganisation of commits that separates key implementation concerns into smaller commits (effectively stacked PRs but clean)<p>The last option would be desirable but it's unreasonable to expect anyone to do it by hand. So this is where <maybe> an LLM could parse my garbage intermediate commits, the final diff and generate a stack instead?
I have had good success lately with asking Claude to do your last option. jj also works fantastically for this, because you can easily jj new up a bunch of empty changes with the descriptions you want to have, and then jj restore the state from your original stack into them. If the process goes poorly for any reason, you still have your original stack around.<p>You don’t <i>have</i> to do it this way, you could use the oplog to undo it all if it’s not to your satisfaction, but it’s much simpler than trying to edit the commits into the right shape directly.
The last option is absolutely not unreasonable to expect people to do by hand, as the article states it’s simply a problem of tooling. JJ makes this extremely easy to do, but some of us have been doing just the same in git for a long time and it is extremely achievable once you know your way around a rebase.
Maybe it just shows my lack of tolerance for process/overhead.<p>As a fellow rebase enjoyer, I will do it occasionally for smaller PRs but to me, it becomes unwieldy for large ones.<p>Do you have any tips or aliases that makes it more workable?
Yep, ensuring RERERE and autostash are enabled eliminate 80% of the tedium for me, but honestly just try jj; it seriously is a gamechanger and (so far, in ~6mth of use) it has had literally zero drawbacks in comparison to git, because it is still git and if I don’t know how to do something with jj, I can use the git commands I do know and it Just Works™
It would be nice if I could click the images to make them larger. As is it's not actually possible to see anything novel being done.
Direct links to the images, until I implement popup on click:<p><a href="https://lubeno.dev/assets/images/blog/lubeno-repository.png" rel="nofollow">https://lubeno.dev/assets/images/blog/lubeno-repository.png</a><p><a href="https://lubeno.dev/assets/images/blog/lubeno-pr.png" rel="nofollow">https://lubeno.dev/assets/images/blog/lubeno-pr.png</a><p><a href="https://lubeno.dev/assets/images/blog/code-review-before-after.png" rel="nofollow">https://lubeno.dev/assets/images/blog/code-review-before-aft...</a>
I wonder how may engineers contribute to their code base on a daily basis.
I don’t want to reinvent the pull request. I want to commit to main like an adult.
I apreciate the fact that they mention that sometimes a commit change needs a fix before it ever even was pull-request ready. I think it would be great to have the ability to easily reorder/modify commits while in active development, and then lock them into permanent history afterwards. Apparently (according to the article) Jujutsu can do that, but I've never had personal exoerience with that VCS.
It blows my mind that Github <i>still</i> doesn't support stacked PRs. Do they never do work that depends on an open PR? Like, as soon as they open a PR they're like "right, better stop doing anything until it's merged"?<p>The file priority thing is a great idea too. That would be even more useful for search. The number of times I'm searching for something on Github and it just shows me a gazillion tests.... Yeah you can look up their advanced search syntax and exclude them probably, but it's always a hassle.
GitHub is putting stacked PRs into private beta around now, actually.
You can manually stack PRs by making the merge target another branch.<p>The workflow just makes it a pain, since you have to manually rebase in both the branch and the UI after the original PR merges.
This blog post is self-promotion, essentially an advertisement for a paid product, Lubeno, submitted by the developer of the product.
... on a website owned by the VC that invested in the developer.<p>I believe that the ideas in the blog post are novel enough and should spark curiosity and interesting discussions. Also I submitted this last week, someone must have hand-picked and given it another chance because it's a good fit for HN.
This is just an ad.
[dead]
[dead]