Feature branch workflow in Git - Commands & Configuration

Introduction

When working on a new feature, you want to keep your changes separate from the main code. The feature branch workflow helps you do this by creating a separate branch for your work. This way, the main code stays stable while you develop.

When you want to add a new feature without affecting the main code immediately

When multiple developers work on different features at the same time

When you want to test your changes before merging them into the main branch

When you want to keep your work organized and easy to manage

When you want to review code changes before they become part of the main project

Commands

Create and switch to a new branch called 'feature-login' to start working on the login feature separately.

Terminal

git checkout -b feature-login

Expected Output

Switched to a new branch 'feature-login'

→

-b - Creates a new branch and switches to it immediately

Stage all the changes you made in your working directory to prepare them for commit.

Terminal

git add .

Expected Output

No output (command runs silently)

Save your staged changes with a clear message describing the new login feature work.

Terminal

git commit -m "Add login feature implementation"

Expected Output

[feature-login abc1234] Add login feature implementation

 3 files changed, 45 insertions(+), 2 deletions(-)

→

-m - Adds a commit message inline

Switch back to the main branch to prepare for merging your feature branch.

Terminal

git checkout main

Expected Output

Switched to branch 'main'

Merge the changes from your feature branch into the main branch to include the new login feature.

Terminal

git merge feature-login

Expected Output

Updating def5678..abc1234

Fast-forward

 login.py | 47 ++++++++++++++++++++++++++++++++++++++++++++++++

 1 file changed, 47 insertions(+)

Key Concept

If you remember nothing else from this pattern, remember: use separate branches to keep new work isolated until it's ready to join the main code.

Common Mistakes

Committing changes directly on the main branch

This can cause unstable code in the main branch and affect others working on the project.

Always create and work on a feature branch before merging changes into main.

Not switching back to main before merging

Merging while on the feature branch merges main into feature, not the other way around.

Switch to main branch first, then run the merge command.

Not committing changes before switching branches

Uncommitted changes can cause conflicts or be lost when switching branches.

Always commit or stash your changes before switching branches.

Summary

Create a new branch for your feature with 'git checkout -b feature-name'.

Make changes, stage them with 'git add', and commit with 'git commit -m'.

Switch back to the main branch using 'git checkout main'.

Merge your feature branch into main with 'git merge feature-name'.

Practice

1. What is the main purpose of using a feature branch in Git?

easy

A. To merge all changes immediately without review

B. To delete the main branch permanently

C. To keep new work separate from the main code until it's ready

D. To create backups of the repository

Solution

1. Step 1: Understand the role of feature branches

   Feature branches isolate new development work from the main codebase.

2. Step 2: Identify the correct purpose

   This isolation allows safe development without affecting the stable main branch.

3. Final Answer:

   To keep new work separate from the main code until it's ready -> Option C

4. Quick Check:

   Feature branch purpose = isolation [OK]

Hint: Feature branches isolate new work from main code [OK]

Common Mistakes:

• Thinking feature branches delete main branch
• Assuming feature branches merge immediately
• Confusing feature branches with backups

2. Which Git command correctly creates and switches to a new feature branch named feature-login?

easy

A. git branch feature-login

B. git push feature-login

C. git merge feature-login

D. git checkout -b feature-login

Solution

1. Step 1: Understand branch creation and switching

   The command git checkout -b branch-name creates and switches to the new branch in one step.

2. Step 2: Identify the correct command

   git checkout -b feature-login is the command that creates and switches to the new branch.

3. Final Answer:

   git checkout -b feature-login -> Option D

4. Quick Check:

   Create and switch branch = git checkout -b [OK]

Hint: Use git checkout -b to create and switch branch [OK]

Common Mistakes:

• Using git branch without switching
• Confusing git merge with branch creation
• Trying to push before creating branch

3. Given the commands below, what will be the current branch after execution?

git checkout -b feature-ui
 git commit -m "Add UI"
 git checkout main
 git merge feature-ui

medium

A. feature-ui

B. main

C. detached HEAD

D. No branch (error)

Solution

1. Step 1: Trace branch switching commands

   The commands switch to feature-ui, then back to main.

2. Step 2: Understand merge and current branch

   After merging feature-ui into main, the current branch remains main.

3. Final Answer:

   main -> Option B

4. Quick Check:

   Last checkout branch = current branch [OK]

Hint: Last git checkout sets current branch [OK]

Common Mistakes:

• Assuming merge switches branch
• Confusing commit branch with current branch
• Thinking merge detaches HEAD

4. You created a feature branch and made commits, but when you try to merge it into main, Git says "Already up to date." What is the likely problem?

medium

A. You are on the wrong branch when merging

B. Your working directory has uncommitted changes

C. The feature branch has diverged from main

D. You forgot to push the feature branch to remote

Solution

1. Step 1: Analyze the error message context

   "Already up to date" means Git sees no new changes to merge.

2. Step 2: Check the branch where merge is run

   If you run git merge feature-branch while not on main, it merges into the wrong branch or shows no effect.

3. Final Answer:

   You are on the wrong branch when merging -> Option A

4. Quick Check:

   Merge branch context matters [OK]

Hint: Always checkout main before merging feature branch [OK]

Common Mistakes:

• Merging while on feature branch instead of main
• Assuming push affects local merge
• Ignoring branch status before merge

5. Your team uses feature branches. You finished a feature and want to merge it into main. Which sequence of commands correctly follows the feature branch workflow?

hard

A. git checkout main; git merge feature-branch; git push origin main; git branch -d feature-branch

B. git merge feature-branch; git checkout main; git push origin main

C. git checkout feature-branch; git push origin main; git merge main

D. git push origin feature-branch; git checkout main; git merge feature-branch

Solution

1. Step 1: Switch to main branch before merging

   You must be on main to merge the feature branch into it.

2. Step 2: Merge, push, and clean up

   After merging, push changes to remote and delete the feature branch locally to keep repo clean.

3. Final Answer:

   git checkout main; git merge feature-branch; git push origin main; git branch -d feature-branch -> Option A

4. Quick Check:

   Checkout main, merge, push, delete branch [OK]

Hint: Always merge feature into main, then push and delete branch [OK]

Common Mistakes:

• Merging without switching to main
• Pushing wrong branch
• Not deleting feature branch after merge