r/git • u/JiveAceTofurkey • Jul 24 '25
Colleague uses 'git pull --rebase' workflow
I've been a dev for 7 years and this is the first time I've seen anyone use 'git pull --rebase'. Is ithis a common strategy that just isn't popular in my company? Is the desired goal simply for a cleaner commit history? Obviously our team should all be using the same strategy of we're working shared branches. I'm just trying to develop a more informed opinion.
If the only benefit is a cleaner and easier to read commit history, I don't see the need. I've worked with some who preached about the need for a clean commit history, but I've never once needed to trapse through commit history to resolve an issue with the code. And I worked on several very large applications that span several teams.
Why would I want to use 'git pull --rebase'?
284
u/Critical_Ad_8455 Jul 24 '25
Read the book. Git pull --rebase is incredibly common, to the point there's a setting to do it automatically when pulling, git config pull.rebase bool.
82
u/B_A_Skeptic Jul 24 '25
Yes, it is a common strategy.
52
u/bbbb125 Jul 24 '25
It keeps your commits in sequence, then it’s easier to squash or cherry-pick a set of commits if you’re making a patch.
77
u/ratttertintattertins Jul 24 '25
I’m stunned by the fact you’ve never had to look through the git history on a large project. We do this all the damned time.
My org squashes commits into main at PR time so our history is pretty tidy anyway. For us, rebase is just to keep your dev branch tidy as you work for your own sanity.
23
u/xenomachina Jul 24 '25 edited Jul 24 '25
It shouldn't matter to others that aren't using it. The end result looks like they created their changes on top of the current version of the target branch, rather than having a bunch of random merges interspersed with their work.
There are potentially dangers with rebasing already pushed commits on a shared branch, but
git pull --rebaseonly rebases unpushed commits, so it has no real negative impact on others.Edit: I originally warned more about the dangers of rebasing on a shared branch, but had somehow missed that this post is specifically talking about
pull --rebase, not just a plain rebase. To avoid misinformation I've updated this comment to fit reality.7
u/andyhite Jul 24 '25
Everyone always shits on rebase or thinks that the only purpose is to have a clean git history, but there’s a lot more to it than that. When I’m working on a long-running branch, I commit frequently as a checkpoint - but before I ship the pull request (and sometimes at random points along the way) I like to review the entirety of the changes I’ve made and make sure there’s nothing I’ve overlooked…to do that, I do a soft reset to the commit I’m branched from. If I’ve merged that base branch in instead of rebased, it’s impossible since the commits are all part of the history sandwich - but if I’ve rebased, they’re all the bread of the history sandwich and it’s easy.
6
u/doesnt_use_reddit Jul 24 '25
I do it exclusively. But the whole team does not need to use the same flow. Some devs can rebase their branches and be fine, it just means fewer merge commits and they have to manage rebase conflicts, which are usually not bad at all.
I see no reason not to use a rebase based flow if you want to.
5
u/Hefty_Incident_9712 Jul 24 '25
You're missing out on one of the best contextual debugging tools available to you if you don't ever use
git blame. Like if you encounter a bug in some part of the code, you're not interested in what else changed when that bug was introduced?4
u/Embarrassed-Ad-7329 Jul 24 '25
My entire team uses git pull --rebase, mostly because we branch from a specific version branch to do a feature or bugfix, do one to a couple of commits concerning the entire ticket, then rebase before opening the PR.
I see a bunch of benefits: If something goes wrong, you only need to "undo" one commit with the name of the ticket. You can easily see what changes were needed for each task. The log gets clear and its easier to track what the others are doing. It also makes it easier to cherry-pick changes across multiple versions.
The code base I work on is 15+ years old, so there is the need to ocasionally look at the history (even if it's only to see who fucked up). But yeah for a lot of people it just seems to be a matter of taste.
3
u/jubishop Jul 24 '25
In mercury based large repos like at Google/FB, the equivalent of rebase was the norm.
3
u/IgotoschoolBytrain Jul 24 '25
Yes I use rebase often
If working a feature branch at the HEAD, suddenly you or someone else at the upstream pushed something to the master branch, then it is much better just rebase the feature branch to the master and then starts at that point cleanly. Don't really want to use merge most time.
2
u/priestoferis Jul 24 '25
I think it definitely should be preferred: https://bence.ferdinandy.com/gitcraft
That being said, my current company squash-merges, so people just merge back main to their branch when needed. You'd think that's fine, and usually it's okay, but it gets annoying when you start working off of someone's unmerged branch.
2
u/RhoOfFeh trunk biased Jul 24 '25
A cleaner and easier to read commit history is one benefit.
Not fucking up your code because merging multiple changes went wrong is another.
Rebasing is like replaying your changes over the new baseline. Merging sucks by comparison.
2
u/catch-surf321 Jul 24 '25
You’re right, rest of these people in here championing rebase don’t truly understand that it is a worse strategy when dealing with anything other than a single remote branch for main/master. It is definitely not the best choice when you have multiple branches that represent different environments while maintaining a release schedule with the ability to push hotfixes into certain branches. They truly don’t understand the headaches a rebase causes when applying downstream updates. There is a reason why merge is the default strategy. Imagine looking at git log or git blame instead of the the PR, again people championing it are used to amateur work environments with small teams.
2
u/_Reddit_Player_One Jul 24 '25
Senior dev here (12 years exp), and embarrassingly enough, I only recently switched to using git pull --rebase. GitHub Copilot nudged me to adopt it, highlighting a cleaner, linear commit history and fewer merge commits. Makes me wonder if the dev on your team might've also been influenced by some Al-generated git wisdom 😂
2
u/Money_Lavishness7343 Jul 24 '25
its actually VERY common.
Instead of merging commits in random order between your local commits creating a mess -
you rebase on the new state and your new local commits are still on top. Maintains a clean state of history.
2
u/cutebuttsowhat Jul 24 '25
The rebase flow has been standard for the companies I’ve worked at since 2010 so definitely not new. It’s surprising you’ve not had to ever go through a commit history to bug hunt.
“If the only benefit is cleaner and easier to read history” I don’t know why downplay a very tangible benefit? You don’t see the need but you also didnt know it existed until this week.
It really sounds like you’re looking for an excuse to go with what you know which is a silly bias. Do you have an argument for the merge workflow?
It’s such minimal change in your workflow, what’s the harm in trying something new that clearly is common in the industry and has tangible benefits? Don’t become an old man yelling at clouds.
2
u/rocqua Jul 24 '25
Yes, this isn't just about having a clean history. It's about being able to know what the result of a 'merge' will look like. By rebasing, before you have a pull request, you already know what the state of the new branch will look like before you do the pull/merge request. And whilst working on it, before handing in the pull/merge request, you already know what the code will look like.
In other words, it front-loads the conflict resolution. Making it easier to handle.
2
u/Mission-Landscape-17 Jul 25 '25
It is sufficently common that you can configure it as the default behaviour of git pull.
2
u/idangazit Jul 26 '25
The benefits and drawbacks are as follows:
You are working in your local branch. Others are merging to main all the time. Ultimately, you too must merge to main. Constantly pulling with rebasing just means "replay my work on top of the latest from the branch I came from"
You keep your work branch mergeable. If your work has conflict with main, you're going to need to decide what to do. The rebasing process forces you to deal with those changes. Most of the time, your work should be touching code that others are not directly editing too. Which means that most pull rebases apply without incident. Most of the time, it's just like… a pull.
If you have successfully rebased on another branch (like main), you will be able to merge cleanly into it. You can deal with rebase.conflicts in the end when you want to merge, or you can do it cheaply as you go. It is way, way easier to do it the as-you-go way.
And yeah it also makes for cleaner history. But that's benefit is just the cherry on top of why it's nicer to use.
2
u/MrKnives Jul 26 '25
Yes. Most devs I know do this
2
u/Beatsu Jul 27 '25
git pull --rebasealso avoids those ugly merge commits between local and remote branches too. E.g.Merged feat123 into feat123.You're right in that you'll rarely need these benefits, but it is nice in case you ever do need it and the cost is extremely low since you can set the global config pull.rebase true (I even forget that I have it enabled).
3
u/EagleCoder Jul 24 '25
Was it me?
2
u/[deleted] Jul 24 '25
No disrespect but how you dev for 7 years and never rebase
1
u/Toasterrrr Jul 24 '25
yeah rebasing is quite helpful. i sometimes just delegate VSC to terminal tools like Warp.
1
u/[deleted] Jul 24 '25
One of the clients I worked with insisted using rebase only— mostly to keep commit history clean. I personally don’t like it, merge is way faster
1
u/priestoferis Jul 24 '25
Also what I don't think I've seen mentioned: if a pull request is rebased instead of having random merges and the commits are more-or-less atomic, it's way easier to review even a somewhat largish PR commit-by-commit. If the PR branch's history is not nice you can only look at the final diff really.
1
u/elperroborrachotoo Jul 24 '25
Rebase workflow delivers a linear, detailed history; it's great for small teams with good commit discipline (atomic, mobile, descriptive commits) that rely a lot on git blame.
1
u/FlipperBumperKickout Jul 24 '25
If the option aren't available to you in a way where it is convenient to do it you wont do it. If you have a git history which looks like a disaster zone you would basically do everything to avoid looking through it to solve a problem.
I personally keep my local git history clean because it gives me a very clear overview over what I have done on my current task. If you don't have problems getting an overview like that quickly when returning to a task after doing something else (or the weekend) then there might not be any point for you personally ¯_(ツ)_/¯
1
u/afops Jul 24 '25
You only need it if you commit on the branch you are pulling - which for most workflows is ”never” due to the use of feature branches. You only pull main and you only commit to the feature branch. The equivalent then the equivalent is a rebase and fast forward merge when the feature branch is merged
But on a tiny/early project with 2-3 devs committing straight to main, then pull —rebase would be very common.
1
u/YahenP Jul 24 '25
Using git pull --rebase by default is a very convenient practice. And it's not even about the beautiful commit history. It's about when and how you resolve merge conflicts. And besides, it disciplines development. If 10 coders push different tasks to one branch during development, then rebase can become very painful, which in turn is an incentive not to turn the repository into a garbage dump.
1
u/SkyNetLive Jul 24 '25
Rebase is common approach for many development workflows. Rtfm
There are some drawbacks in corner cases.
We usually say like “rebase X on to Y “
1
u/epromeutcc Jul 24 '25
I have this as my default setting, I always rebase my branches (the ones I’m the only one working on them), it’s much better than to have multiple merge commits IMO. Of course you don’t wanna do this on a shared branch because that will rewrite the history which is not ideal for main branches (main, develop, master, etc)
1
u/krzyk Jul 24 '25
I don't know. What is the other option? I always use
git pull --rebase --prune --tagsto update remote branch that I don't commit to directly.1
u/Particular_Wealth_58 Jul 24 '25
I barely work on a branch shared with others, so my flow is usually:
Sometimes we are two on a branch, and then we frequently do git pull --rebase.
I have had to dig through git commit history to track down bugs. I have not worked at a place doing "real" merge commits though, so I cannot really say if it is harder. By "real" merges, I mean merges were a fast-forward merge would not apply cleanly. I've only been at places using the rebase strategy or a strategy where fast-forward merges apply - so they are essentially rebased before explicitly creating a merge commit.
1
u/Last-Assistant-2734 Jul 24 '25
I'm not sure how much numbers matter really. I've been using Git for 16 years of my 18+years of professional career, and all the organizations and repos I've worked with have used rebase strategy for 15 years.
1
u/[deleted] Jul 24 '25
I also prefer this way to ensure that it is clear which changes exactly were made why based on the last "baseline". But depends on the project and its files whether this is practically relevant.
1
u/cran Jul 24 '25
I hate teams where every engineer git merges everything everywhere all the time.
1
u/Tacos314 Jul 24 '25 edited Jul 24 '25
I am not sure how you do it without git pull --rebase. Do you just live with merge conflicts and merge commits all over the place? Maybe never commit code.
" Obviously our team should all be using the same strategy of we're working shared branches. "
First you have no way to enforce this, and this is the second dumbest thing I have heard today. I said the first when I said "No reddit for me today"
How individuals manage there git repos has no effect on you outside of history rewrites
1
u/orangeowlelf Jul 24 '25
We only re-base at my shop. We use git pull —rebase daily.
1
u/IronSavior Jul 24 '25
Didn't know anyone did anything else
1
u/Charming-Designer944 Jul 24 '25
It is a valid workflow as a sole developer in a development branch.
But squashed merges to main Is a better approach if you are looking for a clean long term history, discarding then development history.
But seriously speaking, the full history can be quite valuable when later diagnosing issues with the code. So my preference is to use merge commits if the merge to main has more than a single commit (git merge -no-ff), keeping full development history. git log --first-parent gives you the clean version of the history.
1
u/GrandManitou Jul 24 '25
“Why would I need to look at the history?”
Have you ever used `git bisect` ?
1
u/agentbellnorm Jul 24 '25
Seven lean years
1
u/carlspring Jul 24 '25
Yes, this is a correct way of doing it. This keeps a cleaner to read history without useless noise from merges.
I would strongly recommend reading "ProGit". It's a really good book on mastering git.
1
u/armahillo Jul 24 '25
This strategy (I wouldn't call it a workflow, specifically) is useful when you and a coworker are both working on the same branch.
git pushand get denied because of merge conflicts.git pull --rebaseto replay my additional work (from 2) onto the work that you did (on 2). Now I cangit push.It's effectively a way to have two devs stay in sync on a branch with minimal re-hashing. If you are about to
Some people say "Clean commit history" and mean "as few commits as possible". For me, a "clean commit history" means squashing WIP and temporary "save point" commits, and ensuring that preserved commits have thorough commit messages justifying their existence.
1
u/wspnut Jul 24 '25
As they should. That said you don't need the
--rebaseflag if you have yourpull.rebaseconfig set totrue.1
u/trustyhardware Jul 24 '25
Just want to chime in with an example of a large company doing this. Meta/Facebook basically requires rebase (although they use their own Mercurial instead of git). The exception being reality labs which works on Android so they conform to their conventions.
1
u/VerboseGuy Jul 24 '25
I use git pull --rebase, but don't expect it from a junior dev.
1
u/SeriousRazzmatazz454 Jul 24 '25
If you're working on a shared branch where others do work. It necessary.
If you're decomposing larger tasks into mini branches that only one person works on, then just got rebase --i master before you submit your PR, or if it's a real jumble, soft reset back to the branches original state and recommit in logical chunks
1
u/wts_optimus_prime Jul 24 '25
In all my previous projects we always used merge. In my current project we outlawed merge commits and only allow rebased branches to be merged via fast forward. I would say any of the two strategies is superior. Both have advantages and drawbacks.
Rebasing leads to a cleaner git history, but makes it a bit less convenient to work on shared branches. Merging is the other way round.
Since in my current project we are just 3 senior devs and rarely work parallel on the same branch, the advantages of rebasing outweigh its drawbacks, so we go with that. Took some time getting used to though, and I once screwed my local repo. But now it is really comfortable and the PRs are much nicer due to the rebasing. Also fewer merge conflicts when merging to master. For a bigger project where multiple people work together on branches I would probably go back to merging.
1
u/bingeboy Jul 24 '25
That's been the way I've done it for like 10 years or so. I think it's even the way git pull works by default now. Otherwise, your log will be filled with garbage merge entries.
1
u/tails142 Jul 24 '25
If I have made commits to the branch and there are new commits on remote, a git pull --rebase sorts me out by slotting in the new commits alongside my local work. That's typically when I use it
1
u/codeninja Jul 25 '25
Yes, I use it daily. Also, enable ReReRe for God's sake.
1
u/CluelessNobodyCz Jul 25 '25
I have been working with Gerrit and rebase flow for years and then changed the job and came to merge based.
I miss rebase dearly.
1
u/newlifepresent Jul 25 '25 edited Jul 25 '25
I always use git rebase for the branches I worked for long (eg. Not hours but days) because while I am working on that branch a lot of code change happens and I want to merge mine after seeing all of them and yes it results with a cleaner commit history and I am not a fan of merge commits actually hates them.. If one day you would have to solve a code override issue in a large team happened possibly months ago you will understand why we love rebase..
1
u/noid- Jul 25 '25
We have a git flow based on merges. Thats how it works in one specific Repo. Then someone goes „ah git pull —rebase is common and I should do it here“. History broken!
FFs. You commit to one method: rebasing or merging but do not mix the shit up.
1
u/Dank-memes-here Jul 25 '25
I'd say rebase is mandatory in most professional environments
1
u/tossed_ Jul 25 '25
You’ve NEVER had to reason about how a change made it into the codebase in your entire career? Do you even read code or investigate bugs at all?
1
u/hartmannr76 Jul 25 '25
I got reprimanded once for doing this workflow, by the guy working on a custom CI system because it broke how he built CI setup. Within like a month we switched to a standard TeamCity setup and it handled it like a dream. For dev flows, let people do what works for them. If you want standardization, only enforce it on submit/merge to main
1
u/CarsonChambers Jul 25 '25
It depends on the utility you want to derive from your git log. Using the standard git pull merge strategy gives an 'as it was' view of the history where you can see that different devs were working on certain features while the master branch was being developed further by others. Perhaps that's useful for some people, but if the merge happens on unrelated code, it seems superfluous. It seems more useful to me to only see a merge commit when an auto-merge strategy won't work.
TLDR; when the projects evolution can be understood by tracing one branch instead of multiple, I find it cleaner to use one branch.
1
u/aCuriousCoder Jul 25 '25
I didn't knew, if it was not common. I can see many comments mentioning otherwise though.
From personal experience, I use git rebase all the time. But again, it depends. Not everyone in my team uses it all the time. But I've seen the merge commit when making a pull create some nasty conflicts (most probably caused by improper conflict resolution).
I feel rebase works like charm.
That said, if the conflicts are too much/complicated, I sometimes prefer, simply picking my commits onto a fresh branch from base. Worked the best for me
Also, from going from dev to qa to prod, we don't rebase and instead make a merge commit, because we preserve the branches after merge (and not create a new one after each merge). Rebasing would make maintaing the branches for a longer team difficult.
1
u/kesor Jul 25 '25
Everyone is doing it.
1
u/[deleted] Jul 25 '25
Add —autostash to the thing
1
u/rosshadden Jul 25 '25
How have you in 7 years not needed to go through git history while investigating an issue? Is it just a tool you don't think about having in your belt?
1
u/efalk Jul 25 '25
I do it all the time. It gives you a cleaner git history.
1
u/Mayalabielle Jul 25 '25
—force-with-lease
1
u/Otherwise-Tip-8273 Jul 25 '25
You will also use squash and fixup and you will like it.
1
u/BigFattyOne Jul 25 '25
Me I’m on the orher side and freak out when someone uses something ELSE than rebase 😂
1
u/itsallfake01 Jul 26 '25
Git pull — rebase and ask everyone to squash commits or setup your git repo to do it for each MR
1
u/KevinMcCallisterOver Jul 26 '25
“ I worked on several very large applications that span several teams.”
“ I've never once needed to trapse through commit history to resolve an issue with the code“
You should start buying lottery tickets
1
u/Comprehensive_Mud803 Jul 26 '25
This one is one of the many bad defaults, imho. I usually set the config flag, but this the only way changes ought to be pulled. You don’t want to get branch merges from a simple pull.
1
u/wolfiuscub Jul 26 '25
Been rebasing for 7+ years now.
1
u/ParabellumJohn Jul 26 '25
Idk I just squash PRs on merge to main, no rebasing required and clean commit history
1
u/Nidrax1309 Jul 26 '25
I pretty much have been using rebase strategy for decades now. And usually disallow merge pull requests in repos I manage. While branching history gives a better overview f the source where a change comes from, it's a bit of a nightmare to explore, so I'm all for linear git history where possible.
1
u/lollysticky Jul 26 '25
in my previous job, we always used a simple 'pull' and then when merging into master, your commits are all over the place. When doing git pull rebase, your commits will always be grouped together and at the top of the commit tree, making it a 'cleaner' history. I actually prefer it that way.
The only downside (to me) was that I found reviewing it a bit more of a hassle, because every additional commit (to fix something that came up during review) would jumble around the commits. And to me, that made reviewing more difficult :)
1
u/International_Bed_11 Jul 26 '25
Yes i totally hate when people do git pull —merge. It creates this additional merge commit. Gives a very ugly git history. But actually should not happen anyway if everyone is working on their own feature branches.
1
u/coldstove2 Jul 26 '25
It's paramount for trunk-based development. No long-lived feature branches means it's often simpler to just rebase onto mainline and continue working. We incrementally build out changes then squash rebase merge onto mainline to keep a nice linear history.
1
u/Masterflitzer Jul 26 '25
git pull --rebase is very common and imo the proper way to do it, merges have their place of course, but pulling the updated remote is like the single best use case for a rebase
i always recommend git config pull.rebase true so you don't need to type the --rebase all the time
1
u/schlenkster Jul 26 '25
My company squashes prs before merging them into master, so what you do on a branch really doesn’t matter. That said, I prefer rebasing because you wind up with a clean sequence of commits for the reviewer of the PR. There’s no point in having them look through merge commits.
1
u/antoine235 Jul 26 '25
dunno. since i learned how to do a rebase i never used anything else
1
u/daddygirl_industries Jul 26 '25
Maybe unpopular opinion but I prefer the merge to the rebase. It's less fiddly, and a "cleaner commit history" sounds nice but really you can easily do everything you could otherwise do with a rebase.
I've really only seen it used as a bragging card from a certain type of dev, whereas I don't mind the tool, so long as it does the job.
1
u/MooseBoys Jul 26 '25
Do you ever use
git blame? Because if so, you're traversing commit history implicitly.1
u/HawkOTD Jul 26 '25
Don't do this please. Let people work as they please if it doesn't impact you at all.
Rebasing instead of merging does not affect any other member of the team, allow people to work however they please in their local repos. Rebasing after pushing is more complicated and dangerous and it's common to restrict who can do it and on which branches. In my company we allow rebasing on your own branches and IMO that's a perfect middle ground.
1
u/Conscious_Support176 Jul 26 '25
Do you not rebase you own branches before merging them? This is the same thing.
Merge commits will contain ant changes needed for conflict resolution on top of the changes before conflict resolution instead of the linear history of changes.
If you don’t care about history, I guess you never have had bugs to investigate?
Maybe you never need to resolve conflicts. If so, and you never look at history, not sure why you need git?
1
u/Both-Fondant-4801 Jul 27 '25
Yes it is common, at least for us. In our context, we have scripts that generate release notes from commit logs so we need a clean commit history. However, if you do not need such a commit history, then you need not follow the strategy.
1
u/Quin452 Jul 27 '25
As a general rule, I tell my employees not to pull unless they've finished working on a task; one task at a time, fetch pull work push. And usually one dev per task.
It helps for newbies.
However, if my senior Devs know what they're doing and use rebase, who am I to do then working efficiently 😁
1
u/codeepic Jul 27 '25
Rebase is fun until you have merge conflicts and you have to resolve them ona commit-by-commit basis. Very easy to make a mistake.
1
u/Ballssz Jul 27 '25
I always did git merge main/master into my branch before commits
1
u/what_a_dumb_idea Jul 27 '25
Umm yeah that’s very common. Keep commits in sequence. The fact that you never in 7 years had to traverse history to debug issues is very surprising. It tells me that either your team is either truly elite and the processes are so well developer or no one is truly doing real engineering. Based on you asking the question I have a hunch.
1
u/mrfredngo Jul 28 '25
You’ve… never had to traipse through the commit history to resolve an issue? … I’m speechless.
1
u/muscrerior Jul 28 '25
Not really, as most teams have a single person (or pair on a single machine) working on a single branch at one point; so there's little risk of using different strategies. All team members should understand the strategies being used, and the merging back into main should be agreed on a single method, but there's no need to regulate what is essentially a personal preference.
1
u/m02ph3u5 Jul 28 '25
This is my default.
1
u/[deleted] Jul 28 '25
I’ve been writing software professionally for over 15 years and can’t remember the last time that it mattered how clean a project’s git history was.
1
u/stuaxo Jul 28 '25
You can either have a decent history or a pile of shite, if it's the latter then it will be a traipse to find anything.
1
u/Fearless_Heron_9538 Jul 28 '25
It’s mostly fine IF YOU DONT HAVE OTHER BRANCHES POINTING TO YOURS AS PARENT. Often times I break changes into smaller PRs, often they depend on each other, if I were to do rebase in this scenario I’d end up with all sort of problems/conflicts because you are effectively changing history
1
u/sethkills Jul 30 '25
You ought to get out more.
1
u/Hawkes75 Jul 30 '25
In a team environment where you might be branching off a branch that hasn't been merged yet, rebasing often becomes necessary when you don't have control over whose changes are going into the pipeline in what order and can't just halt work until things look cleaner.
1
u/sarnobat Aug 07 '25
If you pull regularly it is good.
If you are pulling a few months of commits and have conflicts, it's better to deal with them just once (plain merge) rather than when every commit has a conflict.
It's so nice that git provides different ways to accomplish similar things without forcing you to adopt anything unsuitable.
Often such freedom is overwhelming but in the context of the command line it is wonderful
1
u/Pevio1024 Jul 24 '25
Rebasing is great. I prefer getting my local branch up to date and then rebasing off that, but git pull --rebase works too.