Bringing intentionality into design: Why you should commit early and often

We’re all familiar with the cliche that work will speak for itself. So often, when we’re designing, we do so without stopping to reflect. We assume that the output will communicate what we want it to. And we rarely invite other people into our process.

What ends up happening is the intentionality of our work — and all of the big and small decisions that go into the output — get lost in translation. In this worldview, design isn’t a conversation.

The role of a designer is to visualize the team’s collective ideas and consciousness of what “this thing” needs to turn into. Commits are a conduit to starting those conversations.

Commits turn design into a time-stamped conversation

Initially, the idea of committing may feel uncomfortable (cue the metaphors). But if you think about the act of committing practically, it’s actually an informal way of introducing context and conversation into your work. In essence, committing is a mindful approach to design. And ultimately, bringing mindfulness and intentionality into our work makes us better creators.

For many designers, the work never feels “done.” And so, we keep our cards close to protect ourselves from being judged on where we are, as opposed to where we’ve been and where we’re going. But the longer we withhold our designs from a broader group of collaborators and stakeholders, the more tension and anxiety we feel, particularly when it comes time for design review. Commits give us an opportunity to grow as designers and push ourselves to deliver our best output.

When we commit, we send a signal to the group, but also to ourselves: Is this a small change or a big update? Who might be able to voice useful feedback? It’s a time to pause and think about our work — something we often don’t do with intentionality.

Over time, designs don’t mean anything without words. But together with comments, commits turn the process of creation into a conversation, and also capture snapshots of moments in time that you can always rewind to. Ultimately, they communicate a story around your work, showing how and why decisions were made, when and where consensus was reached, and who all had a say.

7 ways to make better commits

When it comes to Commits, the rule of thumb is “early and often.” But how often is too often? Is there a “just right” cadence to committing? The best way to think about committing is in relation to the strides you’re making in both your ideas and your designs. Here are a few of the ways the designers on our team approach Commits:

1. Keep the update short and simple, add emoji

When you see the Commit modal pop up, it sparks a moment of reflection. We try to take out superfluous stuff like “updated bla bla bla” because committing implies that you’ve made an update. Commit descriptions aren’t just about sharing all the things you’ve done, because 4 out of 5 may not have been important. When you’re writing a description, think about what you (and your team) will want to know a year from now. What are the critical bits of context you want to preserve?

Some things to consider when writing a Commit description are:

• What’s changed?
• What problems are you solving with these design changes?
• What should reviewers look for?
• What should they test out?

2. Distinguish between major and minor updates using commit descriptions

We tend to think of commits in two ways: major and “in-between” major. For something like fixing a typo or spacing, consider what your visual timeline might look like. For example, our team names smaller releases “cleanup’’ so everyone knows the commit was a routine house clean vs. a major overhaul.

Tim shares four ways he thinks about commits:

Standard commit

This is like your daily multi-vitamin. The default Commit is intended to keep your workflow moving forward. Use it for:

• Early work
• To get ready for feedback
• To address feedback
• To prepare for review
• Post Branch-update, pre-Merge cleanup

Stashing

Think of stashing as a way to put aside work you’re not yet done with, but will come back to later. Committing this type of work sends the following signal, “I was working on a thing. I’m not done with the thing (and I don’t want to lose this work). I need to come back to it later.” When you’re stashing, you’re letting your team see your progress, but also giving them a heads up that it’s not particularly special, or ready for review.

Structural changes

Sometimes, you’re simply rearranging your artboards and giving them better names, without changing anything else. This type of Commit reflects a file structure cleanup, and is merely a heads up that you’re doing some cleanup.

Visual polish

Commits that fit into this bucket include fixing the padding, updating font size, or correcting a button color. Here’s a great use for that 💅emoji.

3. Invite collaborators and stakeholders using @ mentions

For major updates, be sure to @ mention key collaborators and stakeholders. There are two critical times to use @ mention:

1. The first time you’re asking for feedback.
2. When you’ve received and addressed said feedback.

When you want feedback from a specific person

Getting feedback in Abstract is all about transparency and accountability — and quickly pointing people to the right place for input. Had a chat with an engineer on Slack or in the office about implementing a certain feature? @ mention them directly on the Commit, file, artboard, or Collection containing the feature.

For keeping stakeholders informed

Once you’ve received and addressed feedback, stakeholders who’ve been @ mentioned will get a notification in the app or get an email. And no one will have to ask, “What’s the status of that thing?” in Slack. For stakeholders, this means that they’re productively contributing to the evolution of a product, and can remain in the loop if / when things change, or it’s time to go back to the drawing board.

4. Annotate your designs for high quality feedback

Annotation lets you add more context to a comment. You can use them to zoom into a design to get a more holistic understanding of the thinking that went into it. Think of annotations as a way to get people to the most important bit of a design, as quickly as possible, without having to type as many words. Annotations can be helpful to communicate around a feature that needs a bit more explantation, like a panel that slides or a modal that pops up.

5. Use commits with collections

Collections are a great way to share groups of work in one batch. As you commit your changes, the number of artboards you change builds up. To help reviewers focus on what’s most important, you should put a selection of artboards in a Collection, and order them in a logical way. Collections are easy to share, and to get quick feedback (through comments and annotations, see ☝️) from stakeholders.

6. Use commits for archiving

People often ask us, “How do we do explorations with Abstract?” The answer is, “Commit.”

We use Commits for archiving work we don’t necessarily think will make it to the final design because we know we can always come back to it later and have a conversation around it. The workflow we always suggest is: do an exploration, commit, do an exploration, commit, and so forth.

Using commits for archiving allows you to go wide and do your explorations. After the work has been reviewed and a decision has been made, you should do one last cleanup. Then, commit and delete all the other explorations. Rest easy, because all of your explorations are still captured in history—that's the beauty of design version control.

7. Commit at every fork in the road

Each time you arrive at a decision, make a Commit. Then, you can safely travel deeply down one path. If it turns out it was the wrong path, you can revert all of your work back to the fork in the road earlier and try again.

Many thanks to Tim Van Damme, Jordan Staniscia, and Alden Spence for contributing to this piece.