Guide

Git Workflow Guide - Git Flow vs GitHub Flow vs GitLab Flow 2025 Edition

Overview

Git workflows are essential methodologies for establishing consistent branch strategies and development processes in team environments. As of 2025, three major workflows are widely adopted: Git Flow, GitHub Flow, and GitLab Flow.

This guide provides detailed explanations of each workflow's characteristics, advantages, disadvantages, and implementation methods, offering guidance for selecting the optimal workflow for your project. It also introduces the latest best practices using Conventional Commits and commit linting tools.

Details

Git Flow

Git Flow is a structured branching strategy proposed by Vincent Driessen in 2010. It's suitable for complex projects and those with clear release cycles.

Main Branches

• main (master) - Stable branch for production releases
• develop - Integration branch for development

Supporting Branches

• feature/ - For new feature development
• release/ - For release preparation
• hotfix/ - For emergency fixes

Characteristics

• Structured release management
• Enables parallel management of multiple versions
• Clear role separation and processes

GitHub Flow

GitHub Flow is a lightweight workflow focused on simplicity and continuous deployment.

Basic Principles

1. Main branch is always deployable
2. Develop features in descriptively named branches
3. Push to remote regularly
4. Open pull requests for feedback
5. Merge to main after review
6. Deploy immediately after merge

Characteristics

• Simple and easy to understand
• Optimal for continuous deployment
• Suitable for small teams

GitLab Flow

GitLab Flow is a hybrid approach combining GitHub Flow's flexibility with Git Flow's structure.

Environment Branch Strategy

• main - Central development branch
• pre-production - Staging environment
• production - Production environment

Characteristics

• Staged releases through environment branches
• More structured than GitHub Flow
• Easy integration with CI/CD pipelines

2025 Best Practices

Migration to Trunk-Based Development

Modern development teams tend to adopt simpler trunk-based development. This aligns with GitHub Flow and GitLab Flow principles, offering these advantages:

• Easier continuous integration
• Reduced merge conflicts
• Shorter feedback cycles

Adopting Conventional Commits

Using standardized commit message formats enables integration with automation tools.

Recommended Tools

• Commitizen - Interactive commit message creation
• Commitlint - Commit message validation
• Husky - Git hooks management
• semantic-release - Automated versioning and releases

Pros & Cons

Git Flow

Pros

• Clear structure and rules
• Easy management of multiple versions
• Suitable for large-scale projects
• Predictable release cycles

Cons

• Complex with high learning curve
• Poor compatibility with CI/CD
• High overhead
• Misalignment with modern development practices

GitHub Flow

Pros

• Simple and easy to understand
• Optimal for continuous deployment
• Fast feedback cycles
• Suitable for small teams

Cons

• Higher bug risk in production
• Difficult to manage multiple versions
• Limited release control

GitLab Flow

Pros

• Balance between flexibility and structure
• Easy environment-specific management
• Good CI/CD integration
• Accommodates teams of all sizes

Cons

• More complex than GitHub Flow
• Requires environment branch management
• Takes time for initial setup

References

• Git Official Documentation - gitworkflows
• GitHub Flow Official Guide
• GitLab Flow Official Documentation
• Conventional Commits Specification
• Commitizen Official Site
• Commitlint Official Documentation

Examples

Git Flow Implementation

# 1. Initialize project
git flow init

# 2. Start new feature development
git flow feature start new-feature

# 3. Develop feature and commit
git add .
git commit -m "feat: add new search functionality"

# 4. Merge feature to develop
git flow feature finish new-feature

# 5. Prepare release
git flow release start 1.0.0

# 6. Finish release
git flow release finish 1.0.0

# 7. Emergency fix
git flow hotfix start critical-fix
# Fix work
git flow hotfix finish critical-fix

GitHub Flow Implementation

# 1. Create new branch from main
git checkout -b feature/add-user-authentication

# 2. Make changes and commit
git add .
git commit -m "feat: add user authentication"

# 3. Push to remote regularly
git push origin feature/add-user-authentication

# 4. Create pull request (via GitHub UI)
# Or using CLI
gh pr create --title "Add user authentication" \
  --body "Implemented JWT-based authentication system"

# 5. Merge to main after review
git checkout main
git pull origin main
git merge --no-ff feature/add-user-authentication

# 6. Deploy immediately
npm run deploy

GitLab Flow Implementation

# 1. Create feature branch from main
git checkout -b feature/payment-integration main

# 2. Develop and commit
git add .
git commit -m "feat: integrate payment system"

# 3. Merge to main
git checkout main
git merge --no-ff feature/payment-integration

# 4. Merge to pre-production (test environment)
git checkout pre-production
git merge --no-ff main

# 5. Merge to production (production environment)
git checkout production
git merge --no-ff pre-production
git tag v2.1.0

Conventional Commits Examples

# Feature addition
git commit -m "feat(auth): implement JWT token validation"

# Bug fix
git commit -m "fix(api): resolve error when deleting user"

# Documentation update
git commit -m "docs: update API endpoint documentation"

# Performance improvement
git commit -m "perf(db): optimize queries to reduce response time by 50%"

# Breaking change
git commit -m "feat(api)!: change API response format

BREAKING CHANGE: response data array changed to results"

# Scoped refactoring
git commit -m "refactor(components): rebuild button component"

Interactive Commits with Commitizen

# Install Commitizen
npm install --save-dev commitizen cz-conventional-changelog

# Add configuration to package.json
{
  "scripts": {
    "commit": "cz"
  },
  "config": {
    "commitizen": {
      "path": "cz-conventional-changelog"
    }
  }
}

# Execute interactive commit
npm run commit
# ? Select the type of change that you're committing: feat
# ? What is the scope of this change: auth
# ? Write a short description: implement JWT validation
# ? Provide a longer description: (optional)
# ? Are there any breaking changes? No
# ? Does this change affect any open issues? No

Commitlint and Husky Setup

# Install required packages
npm install --save-dev @commitlint/{cli,config-conventional} husky

# Create commitlint configuration file
echo "module.exports = {extends: ['@commitlint/config-conventional']}" > commitlint.config.js

# Initialize husky
npx husky init

# Create commit-msg hook
echo "npx --no -- commitlint --edit \$1" > .husky/commit-msg

# Usage example (invalid commit message)
git commit -m "added stuff"
# ✖ subject may not be empty [subject-empty]
# ✖ type may not be empty [type-empty]

# Correct commit message
git commit -m "feat: add login functionality"
# ✔ Commit message follows conventional commits

Branch Strategy for Team Development

# Initial project setup
git init
git remote add origin https://github.com/team/project.git

# Set branch protection rules (using GitHub CLI)
gh repo edit --enable-auto-merge --delete-branch-on-merge

# Team member workflow
# 1. Get latest main
git checkout main
git pull origin main

# 2. Create work branch (include ticket number)
git checkout -b feature/PROJ-123-add-search-functionality

# 3. Regular commits (Conventional Commits compliant)
git add src/search/*
git commit -m "feat(search): implement basic search logic"

git add tests/search/*
git commit -m "test(search): add unit tests for search functionality"

# 4. Rebase to incorporate latest main changes
git fetch origin
git rebase origin/main

# 5. Push and create pull request
git push -u origin feature/PROJ-123-add-search-functionality
gh pr create --assignee @me --label enhancement

# 6. Address review comments
git commit -m "refactor(search): improve search algorithm based on review feedback"
git push

# 7. Squash merge (keep history clean)
gh pr merge --squash --delete-branch