A day in a real team

Start every unit of work from a fresh, up-to-date branch off main. Never build on a stale base. Fetch first, then cut the branch directly from the remote’s main so you start exactly where production is:

git switch main
git pull --ff-only            # fast-forward main to origin/main, refuse if diverged
git switch -c feat/checkout-coupons origin/main

--ff-only is the safety belt: if your local main somehow has commits that origin/main does not, the pull refuses instead of silently creating a merge. A branch named for its intent (feat/checkout-coupons) is what the PR and the eventual squash commit will inherit.

Do the work as small, atomic commits — each one a coherent, revertable step. A commit should build and tell one story. Stage deliberately and write a real message:

git add -p                    # stage hunks, not the whole tree blindly
git commit -m "Validate coupon code before applying discount"
# ... more work ...
git commit -m "Add expired-coupon error path + test"

Atomic commits are not bureaucracy: they make git revert, git bisect, and code review possible. A reviewer reads a sequence of clear steps; a single 600-line “wip” commit is unreviewable.

Stay current by rebasing onto origin/main — do not let the branch drift. While you work, teammates merge to main. A branch that diverges for days becomes a merge nightmare. Pull their work under yours so your commits always sit on top of the latest trunk:

git fetch origin
git rebase origin/main        # replay your commits on top of the newest main
# resolve any conflicts now, while they are small, then:
git rebase --continue

Rebasing keeps history linear and surfaces conflicts early and in small pieces, instead of one giant collision at merge time. Do this at least daily on a living branch.

Push, open a PR, and revise review feedback with fixup + force-with-lease. Publish the branch, open the pull request, and let CI run. When review lands, do not pile “address comments” commits on top — fold fixes into the commit they belong to:

git push -u origin feat/checkout-coupons      # first publish, sets upstream
# review asks for a change to the validation commit:
git add -p
git commit --fixup=<sha-of-validation-commit>
git rebase -i --autosquash origin/main        # autosquash slots the fixup in
git push --force-with-lease                    # safe force: refuses if remote moved

--force-with-lease is the non-negotiable detail: a plain --force would clobber any commit a teammate pushed to your branch since you last fetched. --force-with-lease checks that the remote is still where you think it is and aborts otherwise.

Once CI is green and review approves, squash-merge and return to a clean main. Most trunk-based teams squash the branch into a single commit on main — the branch’s messy intermediate steps collapse into one clean entry titled after the PR. Then sync and prune:

# merge happens via the PR "Squash and merge" button (or gh pr merge --squash)
git switch main
git pull --ff-only            # bring the new squash commit into local main
git branch -d feat/checkout-coupons       # delete local branch (merged)
git push origin --delete feat/checkout-coupons   # delete the remote branch

The loop is closed: main holds one tidy commit, no branches dangle, and you are positioned to cut the next feature from a fresh base.