Structuring branches in Abstract
Branches are an essential piece of the design workflow and the cornerstone of version control
Jon Gold aptly described design as a “a process of divergence and convergence.” But our design tools weren’t exactly made to support this workflow. In most cases, divergence leads to scattered and fragmented ideas. Convergence is often the path to lost and overwritten work.
With branches in Abstract Branches, you can pursue explorations, solicit feedback from teammates and stakeholders (when you’re ready for it), experiment with ideas, and work on multiple problems simultaneously.
With a Branch, you can communicate what has changed from the current state to “what could be.” Branches aren’t just a way of working in the now; they pave the road for what you and your team could accomplish in the future. As Abstract product designer Jordan Staniscia likes to say, “Branches are alternate realities of your app. You can try, fail, and succeed in a vacuum.”
Why Branches are the path to innovation
Today, many of us work on a single monolithic project — a series of files that are all independent representations of what we want to make. If you want to update this “thing,” you either have to duplicate it or work directly on that file. Branches give you the opportunity to have a discussion around how you can improve upon the status quo, and do it in a safe space where your work won’t get lost in an abyss of folders.
In Abstract, Branches are an essential piece of the design workflow and the cornerstone of version control.
- Branches allow you to experiment with ideas, without fear of losing them forever or committing them to the source files shared by everyone.
- Branches let multiple designers work off of the same files in parallel, then agree upon which changes should be incorporated in or left in the idea bank.
There are three types of branches: the Main branch, active branches, and archived branches.
The Main Branch: your team's single source of truth
In a design environment, too many great ideas often get mixed into one big thing. That makes it really difficult to focus on shipping the feature that is a priority now vs. all the other priorities that you can work on in the future.
In Abstract, each Project has a Main Branch, which is your team’s single source of truth for that Project. Instead of editing the Main directly, Contributors can create Branches that effectively become personal workspaces.
Ongoing design work in Abstract happens in active Branches. Making a branch is like duplicating your Main files into a personal workspace and tracking all of the changes between Main and work done on that branch. It also allows you to work on different problems, at the same time. For example, you might be revamping an onboarding flow in one Branch and simultaneously working on incorporating force touch interactions into your app on another branch.
When you create a Branch from the Main, you can work on files in parallel without creating duplicates in a shared folder that will then need to be manually reconciled.
It's important to branch with intent and give Branches a meaningful name. At Abstract, we like to create Branches with a focused purpose, such as designing a new feature or changing an existing one.
Abstract tip 💡 Create Branches for a single purpose and merge to Main only once your suggested changes have been reviewed and approved by your team.
Not all of your proposed changes will ultimately make it back to the Main. But those concepts can still end up being useful down the road. Branch archives allow you to capture explorations that you might want to revisit later.
Typically, you’ll want to clean up any drafts or explorations before merging work into Main. Once you’ve merged a branch, you can still access older versions through the commit history in the Branch archive.
Updating from Main
Updating from Main allows you to maintain one single source of truth as you incorporate feedback from other members of your team.
Once you merge a Branch into the Main, Active Branches will show a prompt to “Update from Main.” This allows you to reconcile any conflicts between what’s in your Branch and what’s in Main. If an artboard or symbol that you’ve changed was also changed in Main, Abstract lets you choose whether you’d like to overwrite your changes with what’s in Main or keep your version until you’re ready to merge.
The true power of branching doesn’t lie in what you’re doing when you’re working in the Branch, but more about what happens when you’re done.
Thanks to Payam Rajabi for contributing to this piece.