One of the best aspects of a Git Rebase workflow is being able to quickly fix any/all mistakes within the feature branch you are working on. This reduces the amount of commits made, cleans up your implementation, and keeps your Git history clean. Having a clean history is important for professional engineering.

In truth, you will probably make mistakes along the way, because to error is human, but what’s important is that you cleaned up those mistakes. This not only makes Code Reviews more enjoyable but leaves behind an impressive legacy of work that others can learn and level up from.

Now that you know why fixing your commits are important, let’s learn how to fix any/all mistakes. To start, we’ll create a new repository with an initial commit:

Next, we’ll create a feature branch and work on a simple Ruby implementation:

Now we can test our implementation:

Simple but effective. There’s a problem, though. We need to print the mathematical calculation instead of sentences. To fix, you can edit the calc.rb file and replace the original implementation with the following:

If we run the above, we’ll get the desired result:

We can also make a commit with this fix:

If we look at our Git history, by running git log --oneline, we get a result that looks similar to the following:

Our last commit, "Fixed implementation", is our fixup. We can fold this commit into the "Added calculator implementation" commit by rebasing:

You’ll now have something similar in your rebase editor:

We only need to change "Fixed implementation" from p (pick) to f (fixup). By the way, I’m using Git Rebase Abbreviations which is why you see single letter instructions. With these changes applied you should have the following in your rebase editor:

If you save and exit, the rebase will conclude and you can look at your Git history to confirm the following:

Notice the fixup commit is gone. Even better, the implementation is correct:

Here’s what’s nice about fixing commits like this:

We can take this a step further, though. While everything demonstrated thus far is fantastic, we can work smarter by using git commit --fixup. Let’s say we realized we weren’t suppose to implement addition but multiplication instead. Let’s fix our implementation by using git commit --fixup instead. First, update calc.rb with this code:

Since we already know our SHA when last looking at our Git history, we can make this fix and immediately rebase as follows:

The above will yield the following in your rebase editor:

Notice the fixup! commit. That is Git’s special directive for automatically making a fixup commit so you don’t have to manually move the fixup next to the commit that needs fixing or changing p to f. To emphasize, this is made possible via the following configuration:

Since we don’t need to do anything in our rebase editor, you can save and exist to confirm the following:

This unleashes your ability to make multiple fixup! commits and eventually rebasing to fold them all in before pushing up for code review (or even during code review to keep the changes clean).

Now, you might be thinking: "This is great but could I avoid using the Git Rebase Editor altogether?" Yes, you can! You only need to prefix GIT_EDITOR=true before performing your rebase. This might seem counterintuitive because true looks like you want the editor to launch but is the opposite and disables the editor instead. Let’s run through this one last time by making a fixup to our implementation to calculate subtraction instead. First, start by editing calc.rb with this code:

Then do the following:

Perfect!

There’s still one outstanding issue we should address before wrapping up and that’s the first commit we made. It’s poorly written. We also haven’t pushed our newly minted repository to a remote server so we can fix up our main branch too (‼️ Only do this on a repository that’s never been pushed to a remote server). Here’s how:

That’s a clean and well organized, history. To recap, you’ve learned:

💡 Check out Git Lint if you’d like to automate keeping your Git history consistent and clean.

Enjoy!