There are, in a sense, two kinds of branches.

One kind is shared between multiple developers, lives in the central 
repository, and may be long-lived (e.g. the gputestv6 branch).

The other kind, which is what I think Wolfgang was suggesting (and which is 
considered a good practice in the software development community), is that for 
any change (excluding very minor things like updating comments), you create a 
branch locally on your machine. This would not be pushed to the central 
repository, and need not be shared with any other developer. Each branch 
contains a set of logically related changes. For example, you could have one 
branch where you make changes to an initial condition, and another branch 
where you are trying to optimize the calculation of power spectra (I have 44 
branches right now in my local clone of Pencil). When the changes in a 
particular branch are ready', you then rebase/merge those changes into the 
master branch. The main advantage of doing things this way is there is no 
hurry to push (half-baked) changes to the central repository since
\begin{itemize}
\item[A.] you do not have to continuously deal with conflicting changes from 
others (rather, you just have to deal with it once before finally merging the 
changes; if the branch is short-lived, this should still not be too much of a 
hassle);
\item[B.] you can independently work on multiple things at a time (e.g., if you 
make a commit partially implementing a new initial condition and you later 
make another commit fixing a boundary condition, you can choose to push only 
the latter if both are in separate branches, rather than also being forced to 
push the half-baked initial condition to the repository).
\end{itemize}

After adopting this `micro-branching' development style, it becomes feasible 
to locally run more extensive tests for each set of changes that you intend to 
push to the main repository.
For example, you can use \texttt{bin/pc\_isolated-test} or {\tt git worktree}
to run tests on a particular branch while you simultaneously work on
something else in another local branch.

