How to Create a Branch from Another Branch in Git?

In Git, branching is an essential feature that allows developers to work on different versions of a project in parallel without affecting the main codebase. While creating branches is straightforward, you may often need to create a new branch from another existing branch, rather than from the main branch (typically main or master). This allows you to maintain context or carry over specific changes from the parent branch, enabling a more efficient workflow.

In this blog, we will walk you through the steps to create a new branch from another branch in Git, explain when and why you might do this, and provide best practices for managing branches in a collaborative Git workflow.

Why Create a Branch From Another Branch?

There are several scenarios where creating a branch from another branch can be beneficial:

1. Feature Development: If you’re working on a feature branch that builds on another feature or fix, creating a new branch from that feature’s branch ensures that the new branch starts with the latest changes.
2. Bug Fixes: If you need to address a bug that was introduced or exists in a specific branch, creating a branch from the bug-prone branch allows you to resolve the issue without affecting unrelated work.
3. Hotfixes: If there is a need to fix something critical but in a specific branch (e.g., a release branch), you can create a hotfix branch from it.
4. Isolating Changes: Sometimes you might want to isolate certain changes and work on them separately before merging them back into the main development branch.

---

Steps to Create a Branch from Another Branch in Git

1. Ensure You Are on the Correct Base Branch

Before creating a new branch from an existing one, you need to make sure you’re on the branch you want to branch off from. For example, if you’re working on a feature branch (feature/login) and want to create a new branch based on it, you should first check out the feature/login branch.

Command:

git checkout feature/login

This command switches your working directory to the feature/login branch. If the branch doesn’t exist locally, you can fetch it from the remote repository first.

Alternative (Git 2.23+):

If you’re using Git 2.23 or newer, you can also use the git switch command:

git switch feature/login

2. Create a New Branch

Now that you’re on the correct base branch, you can create a new branch. The new branch will include all the changes from the branch you’re currently on (in this case, feature/login).

Command:

git checkout -b feature/checkout-button

This command creates a new branch called feature/checkout-button and immediately switches to it. The -b flag is used to create and switch to a new branch in a single command.

Alternative (Git 2.23+):

You can also use the git switch command to create a new branch:

git switch -c feature/checkout-button

3. Push the New Branch to the Remote Repository

After creating the new branch locally, you’ll likely want to push it to your remote GitHub or GitLab repository to share it with collaborators. To push the new branch to the remote repository:

Command:

git push -u origin feature/checkout-button

The -u flag sets the upstream for the branch, so future git push or git pull commands will know which remote branch to sync with.

4. Verify Your Branch

To ensure that your branch has been created successfully and that you’re on the correct branch, you can use the following command:

Command:

git branch

This will list all local branches, and the currently active branch will be highlighted with an asterisk (*).

---

Best Practices When Creating Branches in Git

Creating branches from other branches can be powerful, but it’s important to follow best practices to maintain a clean and organized Git history:

1. Keep Branch Names Descriptive and Consistent

Branch names should clearly describe the purpose of the branch. Some common naming conventions include:

• feature/feature-name
• bugfix/issue-name
• hotfix/critical-issue
• release/version-name

Consistent naming helps teams understand the purpose of each branch at a glance.

2. Avoid Creating Long Chains of Branches

While it may be tempting to create branches from other branches multiple times (e.g., branch-A → branch-B → branch-C), this can lead to complex, difficult-to-manage branches. It’s generally a good idea to create branches directly from the main development branch (often main or develop) to avoid overly nested or long-lived feature branches.

3. Regularly Sync with the Parent Branch

If you’re creating a branch from another branch, especially if it’s an ongoing development branch, regularly sync it with the parent branch to keep up to date with any changes made there. This ensures that you’re working with the latest version of the code and reduces the likelihood of merge conflicts.

Command:

git pull origin feature/login

4. Create Pull Requests for Merging

Once your work on the new branch is complete, use pull requests (PRs) to merge your changes back into the parent branch. PRs are a great way to review changes and maintain code quality. Ensure that the parent branch has been tested and is in a stable state before merging your new branch back.

---

Example Workflow: Creating a Branch from Another Branch

Here’s an example of how a typical workflow might look when creating a branch from another branch:

1. Start with a Feature Branch:
   You’re working on a feature in a feature/login branch.
2. Create a New Branch for a Related Feature:
   You realize you need to work on a separate but related feature (for example, feature/checkout-button), so you create it from feature/login:

   git checkout feature/login
   git checkout -b feature/checkout-button

3. Make Changes:
   You work on the feature/checkout-button branch, making changes to implement the checkout button.
4. Push and Share:
   Once you’ve made significant progress, you push the branch to the remote repository:

   git push -u origin feature/checkout-button

5. Open a Pull Request:
   After testing your changes, you open a pull request to merge feature/checkout-button into feature/login, ensuring everything works as expected.
6. Merge and Clean Up:
   After review and approval, you merge the changes, and then delete the feature branches locally and remotely to keep the repository tidy.

---

Conclusion

Creating a branch from another branch in Git is a straightforward process, but it’s a powerful technique that allows you to structure your development workflow more efficiently. By following the steps outlined above and adhering to best practices, you can create a more organized Git history and avoid conflicts when managing features, bug fixes, or releases.

By leveraging branching effectively, you can isolate changes, maintain context, and collaborate more seamlessly with your team, resulting in a cleaner and more productive workflow.