Respect the Platform

Most products live on the web and/or on mobile. Each of those platforms come with certain expectations, both from the platform itself and from the users.

I believe that products should embrace the platform that they’re on. Not just make it work, but really try and use it to its full potential. For example:

• Be accessible. Accessibility benefits everyone. Closing a menu by tapping outside of it, dismissing a modal by hitting Escape, filling a form by using autocomplete—all standard accessibility features, and things we all benefit from.
• Be adherent. On mobile, follow the Human Interface Guidelines or Material Design design system closely. On web, use semantic elements, don’t hijack native functionality, and be as open as possible.
• Be lenient. Meet your users where they are. If they want to download your app, great. But app fatigue is a thing, so don’t force it upon them.

Respect the User’s Privacy

Users share their data with you in confidence. Earn that trust, and then keep earning it. For example:

• Be compliant. Regulations can be a pain (looking at you, cookie banners), but at the end of the day they’re there to protect your users.
• Be conscientious. Always try and act in the best interest of your users. I want to believe doing the right thing will take you further.
• Be disinterested. Ask only for what you need. You can’t mishandle information you don’t have. It also removes friction for the user by not having to enter and maintain it.

Respect the User’s Time

Everyone’s busy, and no one wants to waste their time. Catering to this goes a long way in making your product feel friendlier. For example:

• Be efficient. Don’t stand between your users and your product any more than you must. Keep the signup and onboarding flow as short as possible, don’t hit your users with endless modals for your newsletter, and let them get value out of your product as quickly as possible.
• Be fast. Speed can almost always be improved, and users will always appreciate products getting faster. It increases their efficiency, it prevents wasting resources, and it opens up your product to those with slower connectivity or devices.
• Be welcoming. Not just on the way in but also on the way out. If a user wants to delete their account, let them. Of course you’d rather keep them around, but forcing this through dark patterns won’t do anyone any good in the long run.

Conclusion

These are just some of the principles I try to adhere to. The list and examples are non-exhaustive and there'll always be room for improvement, but I believe it's a strong foundation for any product to be good.

Fortunately, I found a workaround to create collages without having to install a third-party app. It uses Apple’s Keynote, which you might already have pre-installed. If not, it’s another free download, just like iMovie.

Instructions

For each of the clips that you want to include in the collage:

1. In iMovie:
   1. Isolate the clip
   2. Go to File → Share → File… in the menu bar
   3. Follow the steps and save the file
2. In Keynote:
   1. Create an empty slide
   2. Drag the file from 1.3. into it
   3. Under Format → Movie, deselect Start movie on click

Once you have all your clips added, you can preview the result by clicking Play or hitting Option-Command-P. When you’re happy with everything:

1. Go to File → Export To → Movie… in the menu bar
2. Set Go to next slide after to 0 seconds to prevent this time from being appended to the video
3. Follow the steps and save the movie

Your collage is now ready to be imported into iMovie.

Tips

Iterative Process

In case your collage is part of a larger video, I recommend keeping the clips in a separate iMovie project so that you can come back later to make changes.

Keynote Only

I find iMovie works well for editing clips, as the feedback loop is quick. The audiowave guides you in trimming the clip, clicking somewhere with the mouse and then hitting Space will let you preview the result, and you can easily see the duration of all your clips by hovering over them.

For quick and simple collages, though, you can also do this with only Keynote. After dragging in a video, select it, then go to Format → Movie. Under Edit Movie you can trim it as needed.

Portrait Mode

If you want to include clips that were shot in portrait mode, you’ll find it exports from iMovie with black bars on the sides. To prevent this:

1. In iMovie:
   1. Select the clip
   2. Click the Cropping button just above the video preview
   3. Rotate the clip so that it’s on its side
2. Export from iMovie and import into Keynote following the instructions
3. In Keynote:
   1. Select the clip
   2. Click Format → Arrange in the top right
   3. Under Rotate, set the angle to correct for your earlier rotation (either -90 or 90, depending on how you rotated it)

Your clip will now be showing normally and without black bars. Note that the height and width of the clip still reflect the imported rotated clip, so you’ll need to take that into account when making changes there.

Since then I've been playing around with some of their new features, and there are two in particular I found interesting: the ability to create subroutines and the ability to show macro groups in the menu bar. I decided to build out a minimal Pomodoro app around these features—partially for the learning experience, and partially at the request of my partner.

The complete macro group can be downloaded from the conclusion.

Background

The Pomodoro technique is a time management method that has you alternate between periods of focus and short breaks. Typically it's 25 minutes of work followed by 5 minutes of break, to be repeated however many times.

There are plenty of dedicated apps for this, but I want to do it with just Keyboard Maestro. On the one hand for the reasons mentioned in the introduction, and on the other hand for the deep integration it provides me with my other macros.

Behavior

The way it works is as follows:

1. At rest, there's a menu bar item to start a Pomodoro.

   

2. Clicking that allows configuring the next Pomodoro: the duration of each interval and the number of loops. This defaults to 4 loops of 25 minutes, for a total duration of 2 hours.

   

3. Starting a Pomodoro shows the remaining time.

   

4. The break state is shown when relevant.

   

5. After the break, steps 3–4 are repeated, until there are no more loops remaining.

Since this is all done with Keyboard Maestro I can easily hook into any of my other macros. For example, when a Pomodoro starts it turns on Do Not Disturb and turns my desk light red, and at the end of a Pomodoro it resets both. This part is really up to you, but having it together with all other macros offers a lot of flexibility.

Macros

The macro group contains four individual macros, and is set to display in the menu bar with a title from the variable POMODORO_TITLE. It has no icon, since I prefer to set that through text to have it display in the same color as the text.

[!NOTE] For custom icons you can download Apple's SF Symbols for free. This is the same set as is available within Keyboard Maestro itself.

Start

This macro contains two groups called "Logic" with some actions in between. Those macros in between are up to you, and aren't strictly necessary—they just allow for initiating anything else when starting a Pomodoro. The reason of grouping actions together in those "Logic" groups is purely to make it easier to indicate what's actually necessary for the functionality and where to add in custom actions.

In the first "Logic" group it first prompts for input, allowing configuration of the number of loops and the duration of each Pomodoro. I deliberately placed the Local Loops input first, since it seemed more likely to be customized than the duration. While the prompt is open, Enter will start the Pomodoro and Escape will close the prompt and cancel the macro.

In the second "Logic" group I use the configured duration to set the time remaining. This is used to keep track of the Pomodoro progress. I then enable the stop macro and disable this macro, which ensures that only one of them will ever be visible in the menu bar menu: "Start" when no Pomodoro is running, and "Stop" otherwise (see also my approach to starting and stopping modes). Finally, I execute the update macro.

Update

The first action saves the ID of the macro instance. This is later used to cancel that specific instance, which is needed in case a Pomodoro is stopped mid run.

The POMODORO_REMAINING number is then used to repeat a group of actions n times. First it sets the title, and then it pauses for 1 minute. I initially had this macro set up with the "Periodic Trigger", but since that executes every minute on the minute it didn't ensure an accurate timing.

Once the minute has passed, I decrease the POMODORO_REMAINING by 1. If the result is 0 the stop macro is triggered, and otherwise it goes back to the beginning of the repeating group.

Stop

Similarly to the start macro, this contains a "Logic" group and a few actions outside of it. These actions outside are again to allow for customization.

In the "Logic" group, first the earlier saved macro instance is canceled. As described, this is in case the Pomodoro is stopped prematurely through the menu bar item. Important to note here is that this is also the reason the "Execute Macro" action in the update macro was called asynchronously; if not, "Stop" would be seen as a child of the "Update" instance, having it cancel itself.

Next, the POMODORO_LOOPS variable is decreased by 1 to indicate that a run has passed. The following "If" check looks if this value is now 0 (meaning all loops have completed) or if the %TriggerValue% variable is not CONTINUE. That last one needs more explaining.

The stop macro is normally executed by the update macro, but it can also be triggered by clicking the "Stop Pomodoro" menu item that shows when opening up the menu bar menu. In that case, the %TriggerValue% would be empty, so to differentiate that from an automatic execution from the "Update" macro a parameter is passed along. With that, the stop macro knows to cancel the Pomodoro completely when stopped from the menu bar mid run.

If it's stopped completely, it will enable the start macro again and disable this macro, and it will delete all the global variables that were used earlier. That isn't strictly necessary, but I like to keep things nice and tidy.

If, instead, there are still more loops to run, it will set the title, pause for 5 minutes, and then execute the start macro again. This is done asynchronously for the same reason as described earlier.

Set Title

This macro is set up as a subroutine. It accepts a parameter Local State, and then uses a switch action to update the POMODORO_TITLE variable in one of three ways:

• PAUSED: To indicate that it's in between Pomodoros.
• RUNNING: To indicate that a Pomodoro is active and how much time is left.
• STOPPED: To indicate that no Pomodoro is active.

Conclusion

This has been a fun exercise where I played around with the new subroutines and menu bar macro groups, and I'm happy with how it turned out. I'm not quite sure yet what else I'll use the menu bar feature for, but it's an interesting feature with lots of possibilities.

One improvement I'll probably make is to only enable this macro group when sitting at my desk. As with my Dock, I prefer to keep my menu bar tidy, and at my desk is also where it makes the most sense to use for me.

To download the complete macro group, click here: Pomodoro.

macOS

My laptop of choice is a MacBook, and it runs macOS. Everything in this section uses native features and doesn't require any third-party apps.

Spaces

I tend to have apps and windows open for different projects or modes. For example, I have a Safari window with a bunch of personal tabs, another one with work related tabs, and then also some additional apps for work. Instead of keeping all this on the same desktop, I use spaces. This lets me set up multiple desktops and give each desktop its own focus.

To efficiently use spaces, it's important to efficiently switch between them. As explained in the macOS User Guide linked above, by default this can be done in one of three ways:

1. Swipe left or right with three or four fingers on a trackpad, or with two fingers on a Magic Mouse.
2. Press the Control key together with the left or right arrow.
3. Open Mission Control and select the desktop in the top of the screen.

While functional, none of these are ideal. The first one requires moving a hand off the keyboard, the second one does as well (and even after following my suggestion below to add additional arrow keys it's still awkward), and the third one is just plain cumbersome. Sure, you could set up a hot corner for the latter, but then we're back to moving a hand off the home row.

I suggest a different approach. Go to System Preferences → Keyboard → Shortcuts, and select Mission Control on the left. There, look for the two actions Move left a space and Move right a space and replace the default shortcuts with Command-Shift-1 and Command-Shift-2, respectively. Now you can move smoothly between spaces without relocating your hands, and so far I haven't noticed any conflicts.

Assign Apps to Spaces

Once you're using spaces, you might find that the mapping of one app per space isn't always ideal. For some apps this doesn't matter since they allow multiple open windows (such as Finder or Safari), but for others this isn't possible (such as Mail or Messages). When opening these apps, then, there'll be a sudden jump to the space the app is opened on.

Luckily, this can be fixed. Let's say you have a space for work and a space for personal stuff, and both of them need to have access to the Mail app. Right click on the Mail app icon in the Dock and go to Options → Assign To. The default setting is None, but you can also assign the app to a specific desktop (This Desktop) or—what we're looking for here—to All Desktops.

Now, whenever you open the Mail app, it will open on the space that you're already on.

[!NOTE] For this to show up you'll need to have at least two spaces open.

Hot Corners

Hot corners associate certain actions with the corners of the screen, which are then activated by moving the cursor into that corner.

I'm not a big fan of them, since I find them prone to accidental activations and they require moving a hand off the home row. But, there's one I do find convenient, and that's to set the bottom left corner to Put Display to Sleep. It's less of a necessity now while working from home, but back when I was working at an open floorplan office it was ideal to quickly lock my MacBook. I wouldn't even have to think about it—just flick the cursor into the bottom left corner while getting up or walking away and I was set.

To set this up, go to System Preferences → Desktop & Screen Saver → Hot Corners….

Dock

This one doesn't necessarily benefit my productivity, but in general I find that it helps my peace of mind to declutter my screen, and a big part of that is the Dock.

First, I have it set to automatically hide and show. This just removes it from the screen entirely until needed, which isn't actually all that often. To do this, go to System Preferences → Dock & Menu Bar and check Automatically hide and show the Dock.

Second, I removed all apps from it that I never or rarely use. It always surprises me to see people with a bunch of default apps in there without bothering to remove them. Either right click on them and then click Remove from Dock or simply drag them off of it.

Third, I added some spacer tiles, which are just empty spaces that can be moved around to create sections within the Dock. To create these:

1. Launch Terminal.

2. Enter the following command to create a spacer tile:

   $ defaults write com.apple.dock persistent-apps -array-add '{tile-type="spacer-tile";}'
   

3. Enter the following command to restart the Dock:

   $ killall Dock
   

You can add as many tiles as you like, and just as with regular apps they can be dragged around the Dock and removed to your liking.

Screenshots

macOS has extensive screenshot taking capabilities built in. For a full overview see their support article, but here is a summarized overview:

• Command-Shift-3 to save a screenshot of the entire screen to file (by default on Desktop).
• Command-Control-Shift-3 to save a screenshot of the entire screen to clipboard.
• Command-Shift-4 to save a screenshot of an area to file (by default on Desktop).
• Command-Control-Shift-4 to save a screenshot of an area to clipboard.
• Command-Shift-4 then Space to save a screenshot of a window to file (by default on Desktop).
• Command-Control-Shift-4 then Space to save a screenshot of a window to clipboard.
• Command-Shift-5 to start a screen recording.

I particularly like the options to screenshot an area or a window. Also good to know: when you have an area already selected you can press Space to drag the selection around, Option to resize the selection from the center, or Shift to change the selection from just one side while keeping the other as is.

Normally I take screenshots directly to clipboard, but to add markup it needs to be saved to a file. However, if you click on the little screenshot preview in the bottom right of the screen right after taking a screenshot, and then use the markup functionality, you can press Command-Option-C to copy the result to clipboard and prevent it from actually being saved to file. Win-win.

Shortcuts

To round up the macOS section, here are some default shortcuts I use a lot. Some of these might seem simple, but it also means it's a good starting point to really get into the habit of using shortcuts, especially once you start combining them.

Two things I just want to point out:

1. You can often add Shift to a shortcut to do the reverse of the original shortcut. Examples of this are moving focus between elements going forward (Tab) and backward (Shift-Tab), going to the next (Enter) or previous (Shift-Enter) search result, or switching between tabs or applications (see below).
2. You can use the menu bar menus to see available actions and their corresponding shortcuts. Lots of apps have shortcuts available, and the best way to start learning them is to just see what's there. You can also press Command-Shift-/ to search within an app's menu items, which will then highlight where the menu item can be found and what its shortcut is (if any).

General

• Ctrl-x, Ctrl-c, and Ctrl-v to cut, copy, and paste, respectively.
• Option-Delete to delete the previous word.
• Command-Delete to delete the previous line.
• Command-, to open the app settings.
• Command-F to search.
• Command-H to hide the front app.
• Command-W to close a tab.
• Command-Q to quit an app.
• Command-Tab to switch between applications.
• Command-Shift-Tab to switch between applications in reverse order.
• Command-` to switch between application windows.
• Fn-C to open Control Center.
• Fn-E to open the emoji picker.
• Fn-N to open Notification Center.

Browser

• Command-T to open a new tab.
• Command-Shift-T to reopen the most recently closed tab.
• Command-[1–9] to go to the nth tab.
• Command-0 to go to the last tab.
• Command-L to focus on the URL bar.
• Control-Tab or Command-Shift-] to move between tabs.
• Control-Shift-Tab or Command-Shift-[ to move between tabs in reverse order.

Karabiner-Elements

The app powering most of my custom shortcuts is Karabiner-Elements. With it, you are able to set up flexible and powerful keyboard modifications.

There are four modifications in particular I recommend, and I find that the easiest way to set these up is to edit the configuration file directly. Go to Karabiner-Elements → Misc and click Open config folder (~/.config/karabiner). Then, with your text editor of choice, open karabiner.json and add the code samples shown in the subsections below under profiles[x].complex_modifications.rules.

Remap Caps Lock to Escape

I rarely use the Caps Lock key. I just don't shout a lot, and I suspect that's the case for many people. Considering it's so rarely used, then, the Caps Lock takes up quite the prominent position on the keyboard.

Now, the Escape key is useful to me. Not in the least because I use Vim, but even in normal day-to-day use there's plenty of moments where quickly dismissing something with it is great, and by remapping the Caps Lock to Escape it's significantly more accessible.

{
  "description": "Change caps_lock to command+control+option+shift (escape when pressed alone)",
  "manipulators": [
    {
      "type": "basic",
      "from": {
        "key_code": "caps_lock",
        "modifiers": {
          "optional": [
            "any"
          ]
        }
      },
      "to": [
        {
          "key_code": "left_shift",
          "modifiers": [
            "left_command",
            "left_control",
            "left_option"
          ]
        }
      ],
      "to_if_alone": [
        {
          "key_code": "escape"
        }
      ]
    }
  ]
}

[!NOTE] This modification on its own can also be done without third-party apps. Go into System Preferences → Keyboard → Modifier Keys… to change the behavior of any of the keyboard's modifier keys, including the Caps Lock. However, this falls short when wanting to do more complex modifications, as I describe in the following subsections.

Remap Caps Lock to Hyper Key

Didn't I just tell you to remap Caps Lock to Escape? Yes, I did. But that was for a single press. With Karabiner-Elements you can set up more complex modifications where you differentiate between a single press (pressing just that one key) and a combined press (pressing multiple keys at the same time).

The Hyper key is the combination of all four modifier keys—Command, Control, Option, and Shift. Performing this keyboard manually would quickly become painful, and therefore it's a combination that's never used. That's great, because it means that we're free to combine it with any other key for custom shortcuts without having to worry about it conflicting with any app or system shortcuts.

This keyboard modification is what enables nearly all of my macros, as described in the Keyboard Maestro section.

[!NOTE] The configuration for this is included in the previous subsection.

Remap Shift-Caps Lock to Caps Lock

As pure as my intentions are, sometimes I just have to raise my voice from behind the laptop. In such cases it's useful to have an alternative way of activating Caps Lock, considering we have lost the default Caps Lock key. By remapping the combination of Shift and Caps Lock to do this, I keep the new functionality of Caps Lock to act as Escape and the Hyper key while having a way to fall back on the original behavior.

{
  "description": "Use shift+caps_lock as caps_lock",
  "manipulators": [
    {
      "type": "basic",
      "from": {
        "key_code": "caps_lock",
        "modifiers": {
          "mandatory": [
            "shift"
          ],
          "optional": [
            "caps_lock"
          ]
        }
      },
      "to": [
        {
          "key_code": "caps_lock"
        }
      ]
    }
  ]
}

Remap fn + h/j/k/l to Arrow Keys

Lastly, this is an easy way improve my navigational abilities. The arrow keys are useful, but they're badly positioned since they require moving a hand off the home row to reach them. By remapping the fn key to work together with the h, j, k, and l keys to act as arrows they're really quick to use.

{
  "description": "Change fn + h/j/k/l to arrow keys",
  "manipulators": [
    {
      "type": "basic",
      "from": {
        "key_code": "h",
        "modifiers": {
          "mandatory": [
            "fn"
          ],
          "optional": [
            "any"
          ]
        }
      },
      "to": [
        {
          "key_code": "left_arrow"
        }
      ]
    },
    {
      "type": "basic",
      "from": {
        "key_code": "j",
        "modifiers": {
          "mandatory": [
            "fn"
          ],
          "optional": [
            "any"
          ]
        }
      },
      "to": [
        {
          "key_code": "down_arrow"
        }
      ]
    },
    {
      "type": "basic",
      "from": {
        "key_code": "k",
        "modifiers": {
          "mandatory": [
            "fn"
          ],
          "optional": [
            "any"
          ]
        }
      },
      "to": [
        {
          "key_code": "up_arrow"
        }
      ]
    },
    {
      "type": "basic",
      "from": {
        "key_code": "l",
        "modifiers": {
          "mandatory": [
            "fn"
          ],
          "optional": [
            "any"
          ]
        }
      },
      "to": [
        {
          "key_code": "right_arrow"
        }
      ]
    }
  ]
}

[!NOTE] The choice for using h, j, k, and l might seem arbitrary, but it means you can navigate with just your right hand all from the home row.

Keyboard Maestro

With the Hyper key set up, a wide range of new possible shortcuts are unlocked. To best make use of this I use Keyboard Maestro, which is built around the concept of macros. A macro is a collection of actions that can be activated through so-called triggers. You describe what you want it to do and specify how you want those actions to activate and Keyboard Maestro will then take care of it.

This probably sounds a bit abstract, but it's also what makes it so flexible and powerful. More than the other suggestions so far, Keyboard Maestro is a personal app in that it's likely to be tailored to each user's needs and workflows. As such, rather than just diving into the "how", I'll also try and explain the "why" behind my setup.

Organization

The app consists of three main panes: one for macro groups, one for macros, and one for the contents of the macro. These macro groups can be used just for organizational purposes, but also to have them share a certain characteristic (such as for palettes).

As my library of macros grew, I found it helped to keep them well organized. I tried a few approaches, but the one I have now is to use three types of macro groups:

• App · [Name]: These contain macros related to a specific app.
• Palette · [Name]: These open up a specific palette.
• Trigger · [Name]: These contain macros using a specific trigger other than hot keys.

Other than that, I also have a → Subroutines group, with the arrow to keep it sorted on top. This contains macros that I don't use directly; instead, they contain generic actions that I execute from other macros. This lets me keep the main logic in one place, so if I ever have to update it I know where to do it and I only have to do it once.

To use these, insert the action called "Execute a Subroutine". You can define and pass along parameters as well, as well as pass data back to the initial macro. See the examples subsection for inspiration on how to use this.

Palettes

Palettes are by far my most used feature of Keyboard Maestro. With it, a small overlay opens up that lists all the macros within the group, including (optionally) their icon and their trigger.

There's a few different ways of having palettes show up, but my favorite is to use Shows a palette for one action when → The hot key … is pressed. With this, pressing the specified hot key will show the palette, and triggering any of its macros will hide it again.

[!NOTE] Sometimes I open up a palette only to decide I don't want to use any of its macros. Intuitively I'd press Escape to discard it, but that doesn't work—it uses Enter for that instead. As a workaround, I normally add an empty macro with Escape as the trigger. Not ideal, but it makes more sense to me than the default.

As mentioned earlier, the combination of the Hyper key is so impossible it's never used, and it can therefore be freely used for any combination. However, if you start using it for all your shortcuts directly, you'll soon find that you run out of sensible combinations.

So, instead, I use palettes to group macros, and—where possible—use mnemonic shortcuts to trigger them. Once the palette is open you don't necessarily need unique shortcuts anymore, so you can assign each of the macros within the palette a single letter as hot key. With this, it's one more key press compared to directly triggering the macro, but it doesn't pollute your global shortcuts, groups your macros nicely together, and gives you a nice little overlay to see the available macros, in case you need the reminder.

Here are some examples of palettes I use:

• A palette called "Browsers" that's triggered with Hyper-B, letting me open up a new window in any of three installed browsers.

  

• A palette called "Calls" that's triggered with Hyper-C, letting me FaceTime certain people or join certain Zoom calls (with a global mute/unmute).

  

• A palette called "Launchpad" that's triggered with Hyper-L, letting me jump between my most frequently used apps.

  

• A palette called "Modes" that's triggered with Hyper-M, letting me start and end modes such as for work or exercise.

  

• A palette called "Search" that's triggered with Hyper-S, letting me type in a query from wherever and have it directly open up the results.

  

Window Management

I previously used a dedicated app for window management, but when I discovered that Keyboard Maestro has this functionality built in I quickly moved over. I'm sure it lacks some features found in dedicated apps, but it's enough for my needs. I use it in two ways:

• As a palette: Similarly to the palettes described above, this presents an overlay with all my presets, which I then trigger with one additional hot key. I use Hyper-Tab for this, with the mnemonic that Tab is also involved in switching between apps.

  

• As gestures: Keyboard Maestro can recognize gestures you make with your finger on your trackpad as triggers for macros. On its own this isn't very useful because it conflicts with regular trackpad usage, but, again, in combination with the Hyper key (or any other key, for that matter) you're all safe from that. I have a macro for each swipe direction (horizontally, vertically, and diagonally) to let me intuitively swipe a window to a certain side or corner of the screen.

Typed Strings

Macros can also be triggered by typing a sequence of characters. The only caveat here is that it will also trigger when you're in a text input, so you need to make sure it's not a combination of keys you'd normally use. I prefix most of my typed strings with ; so as to avoid that.

These typed strings are particularly useful for inserting snippets of text. I have a few of these, and to keep them organized I namespace them, meaning I group macros with a similar purpose together under the same prefix. For example, I have ;dt for inserting tomorrow's date and ;dy for inserting yesterday's date. And I have a wide range of typed strings starting with ;f which then insert dummy data (such as ;fs for a Lorem ipsum sentence or ;fe for a fake email address).

Finally, I have a few typed strings for characters I frequently use, such as the arrow I use in this post ("→") that's inserted whenever I type ->, or the multiplication sign ("×") that's inserted whenever I type ;x,

Automations

I have a few macros that are set and forget. They're triggered by things that just happen automatically, so they don't require my input. For example:

• Whenever I connect my MacBook to my external monitor my desk light is turned on and Do Not Disturb is turned off (with the assumption that it's time to work and I'll need to see those Slack notifications).
• Whenever I am in a Zoom call my desk light turns red, like an on-air light. Then, it's reset when I disconnect.
• Whenever I connect my external SSD to my MacBook the Time Machine preferences pane is opened so that I can monitor the backup progress. Then, it's closed when I disconnect.
• Once a day a macro runs to check if a certain domain I'm eyeing is available.

Other Examples

Finally, let's dive into some random examples of macros I use and love. As mentioned before, I see Keyboard Maestro as a personal app in that it's likely to be tailored each user's needs and workflows, but I've certainly been inspired myself by seeing others' creativity.

A few of these have been set up as subroutines. In the organization subsection I explain what these are and how to use these.

Making a FaceTime Call

In the palettes subsection I describe my palette for making calls, among which FaceTime calls. The subroutine for this takes a parameter for the contact (like a phone number or an Apple ID) and then takes care of initiating the call.

Making a Zoom Call

Similarly to the FaceTime call subroutine, the Zoom call subroutine takes a parameter to then connect to a Zoom call. What's slightly different is that it leaves it more open what to pass along, so that you're able to join a public call (join?confno=123456789), join a passcode-protected call (join?confno=123456789&pwd=abcdef), or start a call (start?confno=123456789).

Performing OCR

OCR (Optical Character Recognition) lets you pull text from an image. This subroutine only takes care of capturing the image, and then passes along the output to the macro that executed it for further processing. The screencapture command initiates taking a screenshot by dragging the mouse to select an area (-s) and then saves it to the clipboard (-c), and it does this without playing the usual screenshot sound (-x).

Toggling Do Not Disturb

There are a few instances where I need to set the Do Not Disturb state. It's not quite as straightforward as turning it on or off; instead, you need to toggle it. Thankfully, there's a way to check if it is currently active, which can then be used to act accordingly:

Create one that checks if the script is 0 to turn it on, and one that checks if the script is 1 to turn it off. The macro taking care of the actual toggling executes a keystroke, which is a shortcut I have set under System Preferences → Keyboard → Shortcuts. There, select "Mission Control" on the left, and configure a shortcut for the action "Turn Do Not Disturb On/Off". I went with Hyper-0, for no particular reason.

Syncing Browser Scroll Positions

When I'm working on a site I sometimes want to try out different designs of the same element. To do this I open two tabs, make my changes in one tab, and then go back and forth between the two tabs to compare. Of course, it helps to then have the two tabs at the exact same scroll position so that there's no jumping around and you can focus entirely on the design changes.

This macro gets the scroll position from the front browser, saves it, and then, when triggered again within 5 seconds, will scroll to that position. If not used within that time it'll delete it, so that it's reset for the next use.

Starting and Stopping Modes

In the palettes subsection I describe my palette for different modes. Most of these modes just open up a few things, but for my work mode I have a system built in that toggles between starting the mode and stopping the mode.

To do this, in the start version I first perform all start-specific actions, then pause for 0.5 seconds so as not to interrupt those start actions, and then disable the start version and enable the stop version. In the stop version I do the same, except that I enable the start version and disable the stop version.

The great thing is that you can then give both versions the same trigger, and since only one of them will ever be enabled it just toggles between the two.

Conclusion

I could go on and on about all my macros, but this seemed like a good selection to give just a taste of what's possible. If you're interested in hearing more about any of this, let me know on Twitter!