These tips are designed to declutter your mental space. By strategically managing your tools, habits, and workflow, you can eliminate unnecessary tinkering and busywork. Software development demands ample concentration already—there's no need to exhaust yourself further with poor tool choices. After all, what's the point of being a programmer if you're not optimizing your computer to work for you?

Since these strategies stem from my personal workflow, their relevance may vary for you based on your individual setup. A few of the mentioned tools won’t be available if you don’t work on Mac. Still, most of the insights are pretty universal, and will benefit any developer looking to be more efficient.

Master the keyboard

Most developers are at least a little familiar with the advantages of using a keyboard to navigate. Certain tasks definitely require a mouse (plenty of digital ink has been spilled on the topic), but I’ve found there are surprisingly many situations where a keyboard is much more efficient. Learning keyboard shortcuts might be a pain, but knowing them will make you so much faster in the long run! For me personally, it also minimizes the mental overhead associated with changing contexts.

While keyboard navigation is kind of unavoidable once you’re working in a terminal, you might not be aware of the possibilities for your desktop applications. Let me show you how I keep my fingers on the keyboard:

Homerow

Homerow completely changed the way I interact with applications. It maps every clickable thing on your screen to a quick keyboard shortcut, significantly reducing the need for a trackpad or mouse. In applications that don’t provide decent (or any!) shortcuts, this tool bridges the gap and allows you to have everything literally at the tip of your fingers.

When you’re using a laptop without mouse, it works amazingly well for things like clicking on small screen elements (which is a huge pain when all you have is a trackpad). Once I got used to Homerow, I got so much quicker at navigating around my system. It also gave me a new appreciation for accessibility tools, and the hurdles many people face when applications assume reliance solely on a mouse.

Raycast

After thoroughly testing various launcher tools, including Spotlight, Albert, and Raycast, I've found Raycast to be the standout choice. Previously, my productivity workflow was scattered across numerous scripts and tools, leading to a fragmented and less efficient process. Raycast consolidates all your scripts and apps, seamlessly integrating them to provide a versatile cocktail of functionalities, readily available wherever you need them. With a robust ecosystem, you're likely to find a community-sourced extension, script, or snippet that meets your needs. And if not, creating your own scripts is surprisingly hassle-free. If all else fails, there's an API available as your escape hatch for more complex tasks, though utilizing it may require additional effort compared to a simple script.

I've installed numerous extensions and functions, but here are the ones I frequently use alongside some built-in functionalities:

• Clipboard History

• Screenshot (I have a keyboard shortcut for Capture to Clipboard which I highly recommend)

• ScreenOCR

• Floating notes (built-in)

• Search Emoji & Symbols (built-in)

• Window Management (built-in)

• ChatGPT

• Quicklinks (built-in)

• Script commands (built-in)

(as you might expect, I’ve bound most of them to keyboard shortcuts)

Example script: Chrome profiles

I can't emphasize enough how seamlessly Raycast integrates with your existing scripts. Here's an example:

Suppose you're seeking a simple method to launch a new browser window with a specific context. Chrome facilitates this through profiles (which we'll delve into shortly). Here's how you can integrate it using Raycast Script commands:

1
2#!/bin/bash
3
4# @raycast.schemaVersion 1
5# @raycast.title Open work browser
6# @raycast.mode compact
7# @raycast.icon 💼
8# @raycast.description Opens Chrome with work profile
9
10open -na "Google Chrome" --args --new-window --profile-directory="Work"

It promptly appears on Raycast's configuration screen, allowing you to assign an alias and shortcut.

And voilà - you can now run the script from anywhere using the launcher or the shortcut you configured, no terminal needed. Essentially, we have a standard bash script that can operate outside of Raycast; we simply added some metadata to integrate it. While this is a rather straightforward example, trust me, you can accomplish some impressive feats with Raycast using just scripts!

Karabiner-Elements

Karabiner-Elements is a powerful tool that empowers you to redefine the functionality of specific key combinations, so you can easily swap unused keys for more useful ones. People are using it for all kinds of wacky keyboard customizations, but I only really use it for two purposes:

1. Transforming Caps lock into Escape: As an enthusiast of Vim key bindings, I've harnessed Karabiner-Elements to convert my Caps lock key into an Escape key. This seemingly small adjustment has had a profound impact on my productivity, streamlining my Vim-based text editing tasks and allowing me to navigate more efficiently.

2. Caps lock + hjkl to Arrow Keys: Another key remapping that I find incredibly useful is changing Capslock combined with hjkl into dedicated arrow keys. This enhancement makes text editing and navigation a breeze. Instead of reaching for the traditional arrow keys, I can stay focused on my typing and make seamless text edits effortlessly.

Ukelele

With Ukelele you can customize your keyboard layout. I'm working on a Belgian AZERTY keyboard where the backtick key is a dead key by default. This means that it doesn't produce a character on its own but instead modifies the character you type immediately after it. However, I frequently need to use the backtick key on its own (thanks, ES2015), and having to press an extra key each time I use it was a source of frustration. With Ukelele, I was able to make the backtick key directly accessible, eliminating this source of frustration and significantly enhancing my workflow.

Get the most out of your browser

Most of my daily work consists of developing web apps and sites, and a lot of my free time is spent browsing the web as well. Since I’m spending more time in my web browser than any other app, it only makes sense to try and optimize the way I use it. I’m using Chrome as my primary browser, but some of the following tips also work in other browsers.

Context-specific browsing with Chrome profiles

If you haven't delved into the world of Chrome profiles yet, you're missing out on a game-changer for your online productivity. A Chrome profile functions as a dedicated browser context, allowing you to establish separate profiles for various contexts.

For most users, this involves at least two profiles: one for personal use and another one for work-related tasks. I've taken that a bit further to its logical conclusion: you should create a new profile every time you find yourself in a new context. For instance, in my role as a consultant working with various clients, I've created a dedicated profile for each client. This way, I can have unique password managers, bookmarks, and Chrome extensions specific to each client's needs. It allows me to stay organized, ensures I don’t mix up accounts, and customizes my browser to the type of work I’m doing.

Switching between Chrome profiles is easy with Cmd + Shift + M. As we discussed earlier, it's possible to write scripts that open Chrome with a specific profile, and integrate those scripts with Raycast.

You should use a different browser color scheme for every profile. This makes it easy to tell which context you’re currently in (which comes in handy when you’re switching windows or when you’re returning from a break).

Favicon-only bookmarks

By clearing away the text from your bookmarks, only the favicon remains visible. This simple visual hack transforms how you manage and access your frequently used bookmarks. By keeping only the unique icons of your go-to pages and apps visible, you lose the clutter of words, making it much easier and quicker to find what you’re looking for.

Tab management: Close other tabs

Chrome lacks a built-in solution for quickly closing all other tabs (I know, it makes no sense). If you've ever found yourself regularly right-clicking on a tab and painstakingly selecting ‘Close Other Tabs,' you're not alone. Fortunately, there’s 'Close Other Tabs'. In the settings of this plugin, you can easily configure a custom keyboard shortcut that suits your workflow.

Essential Chrome shortcuts

I strongly recommend mastering shortcuts for these actions, since you’re doing them constantly and it takes ages if you have to click through a menu:

1. Close Tab Cmd + W

2. Close Window Cmd + shift + W

3. Open New Tab Cmd + T

4. Reopen Last Closed Tab(s) Cmd + shift + T

5. Go to Address Bar Cmd + L

6. Open Link in New Tab Cmd + "click on the link" or Window shift + "click on the link"

7. Refresh Page Cmd + R

8. Switch Chrome Profile Cmd + shift + M

Improve your Developer Experience

Aside from my browser, the majority of my work at the computer is spent in a code editor or terminal. Developer Experience has been a somewhat controversial term lately, but I strongly believe in the craftsman analogy when it comes to tools: they need to be tailored to you in order to produce the results you want.

Getting your editor or terminal set up the way you want involves a whole variety of tweaks and preferences. I’ll limit myself to highlighting a few things that have worked really well for me.

VS Code

I develop software in Visual Studio Code, and I like it. Most developers have strong opinions on their editor, and many will strongly disagree with my choice. That’s fine, an editor is kind of like making a Bolognese: everyone has their own unique way of doing it, and some are convinced that the only right way is how grandma used to do it. After experimenting I found the perfect Bolognese for me.
In other words: if you prefer a different editor, feel free to skip this part. More power to you!

Visual Studio Code thrives due to its enormous plugin ecosystem. While writing this post I realized I may have a plugin problem, I just keep adding more and more (65 extensions and counting). Here are some of my favorites, beyond the usual suspects:

• Vim: Vim-style keybindings and functionality.

• Peacock: With Peacock you can set color themes for each of you projects. This makes it very handy for differentiating applications if multiple are opened.

• Git Graph: Even for the most ardent terminal-based Git enthusiasts, Git Graph proves to be an indispensable tool, offering a visually appealing and informative overview of your repositories.

• TODO Highlighter: Instantly spot TODOs. (it pairs nicely with Todo Tree.)

• Trailing Spaces: Identify and remove trailing white spaces from your code.

• Indent Rainbow: This extension colorizes the indentation in front of your text, alternating four different colors on each step.

• Code Spell Checker: A basic spell checker that works well with code and documents.

• Javascript (ES6) Code Snippets: This extension contains code snippets for JavaScript in ES6 syntax.

• i18n Ally: In addition to offering an intuitive user interface for streamlining i18n tasks, this extension provides a valuable feature—previewing translations within HTML files.

Extending your shell life

I spend a lot of my time in Chrome and Visual Studio Code, and I use Raycast for a lot of scripting tasks. Still, sometimes a terminal is just the right tool for the job. As with editors, people have very strong opinions and preferences. All that really matters is that you feel comfortable working in a terminal. Here’s how I got there:

Warp: Supercharge your terminal with AI

My terminal of choice is Warp. While I wouldn't outright claim it as the definitive best, I appreciate its integrated AI feature, which has proven to be quite useful in various situations. For example: If you want to change a folder named test to test2 you can just ask Warp AI by first typing #, followed by your question. It will then come up with a script. You should still be skeptical about what it comes up with, but in my experience it tends to be pretty accurate.

Using aliases as daily terminal shortcuts

Aliases are probably the easiest way to simplify your shell experience. They are pretty similar to keyboard shortcuts in a way: learning them takes a while, but they are tremendously helpful once you have them memorized. My rule of thumb is to define an alias once I use a command more than once a day. I try to be pragmatic in this, using shorter aliases for commands I use the most.

I tend to stick to aliases that I’ve defined myself because they match the way I think, but there are plenty of tools that give you common aliases, like Oh My Zsh. These are some of my daily go-to aliases (I use ZSH, so they’re defined in my .zshrc file):

Checkout git branch with fzf

1alias check='git branch | fzf | xargs git checkout'
2alias checkremote='git branch -r | cut -d'/' -f2- | fzf | xargs git checkout'

Merge git branch with fzf

1alias merge='git branch | fzf | xargs merge'
2alias mergeremote='git branch -r | cut -d'/' -f2- | fzf | xargs git merge'

Some of my personal aliases

1
2alias m='merge'
3alias mr='mergeremote'
4alias c='check'
5alias cr='checkremote'
6alias r='npm run dev'
7alias y='yarn'
8alias clean_branches='git branch --merged | egrep -v "(^\*|master|dev)" | xargs git branch -d'
9alias ls='exa'
10alias l='exa --long --git --header'

Automatic switching to correct Node versions

For those of us juggling multiple Node.js projects simultaneously, the need to swap between Node versions for each project is a familiar routine. As always, there are multiple tools that can help you with this, but nvm is the one I’m used to. Unfortunately, you still need to remember to manually switch versions before you start node, which can be a bit of a hassle. To streamline this process, I've crafted a script that automates the switching of Node versions whenever you move from one project to another:

1set_node_version() {
2  if [[ $PWD == $PREV_PWD ]]; then
3    return
4  fi
5  PREV_PWD=$PWD
6  [[ -f ".nvmrc" ]] && nvm use --silent
7}
8
9precmd() {
10  eval "set_node_version"
11}

For the record, there are more extensive versions available in the nvm documentation, but this script is simple enough and has served me without issues.

Take notes & embrace reminders

Obsidian for Notes

After years of trying out different note-taking methods, from Apple Notes and Notion to good old pen and paper, as well as digital options like plain text files and Google Keep, I finally settled on Obsidian as my go-to solution for organizing my thoughts and projects.

What makes Obsidian my personal favorite boils down to a few key aspects:

• No vendor lock-in: Obsidian is just a bunch of Markdown files with some extra sauce.
  This approach resonates with me because it doesn’t lock me into a specific, proprietary ecosystem. The last thing I need is for my notes to become unreadable or impossible to migrate! If I ever feel like Obsidian isn’t working for me, there’s not much stopping me from switch to a different app.

• Plugins: The plugin system in Obsidian reminds me of the flexibility I love in Visual Studio Code (like I said, I may or may not have a problem). The ability to customize and extend its functionality with plugins enables me to tailor the tool to suit my workflow perfectly, adapting as my needs or preferences evolve over time. The way you take notes is inherently very personal, so it makes sense to me that you need to be able to customize your note taking tool the way you like it

• It’s free: Indeed, Obsidian charges for certain plugins and commercial licenses, but at its core, it's entirely free to use with no real limits. While it's not open source (at the moment), many surrounding plugins or integrations are, and the community enjoys experimenting. While I don't necessarily mind paying for note-taking software, it would have to offer significant advantages over the numerous free alternatives.

Apple Reminders for Tasks

While Apple Reminders might not be the most work-related app, it plays a crucial role in enhancing my overall productivity. I've integrated reminders into every facet of my life. The true power of this tool becomes apparent when you establish the habit of consistently maintaining your reminders and following up on the tasks you've set for yourself.

I've fine-tuned my reminder strategy, dividing them into two distinct categories: those with due times and those without. The reminders without specific due times are perfect for creating lists — such as a shopping list or a collection of to-dos.

For the reminders that do come with due times, they represent tasks that adhere to my personal productivity system. To keep myself accountable and ensure these reminders don't slip through the cracks, I've adopted a clever technique on my iPhone (can we still use the term life hack? Because this totally qualifies as a life hack). I place the Reminders app in a folder alongside my messaging apps and activate the badge counter for due reminders. This creates a useful illusion: when a new reminder is due, it appears as though I've received a new message.

My ultimate goal is to maintain a clean slate with no badges on any of my apps. This means I'm constantly prompted to either take immediate action on the reminder or reschedule it for a more convenient time. This approach helps me stay on top of my tasks and responsibilities, ensuring that nothing slips through the cracks.

To top it all off, there’s one more thing that makes Apple Reminders indispensable for me: pairing it with an Apple Watch. For instance, I keep my shopping list in Apple Reminders. Whenever I raise my wrist and instruct Siri to 'add X to my shopping list,' it flawlessly updates my list. This method is equally effective for reminders, ensuring I promptly add new tasks as they arise.

Conclusion

In this blog post, we've explored a variety of strategies and applications. My advice is to avoid attempting them all simultaneously. Choose one to focus on for a few days, really integrate it into your routine. Afterward, you're free to discard it if it doesn't suit your needs. The key lies in establishing the right habits, as trying to adopt everything at once may prove to be more frustrating than helpful.

If you decide to try out any of the tips or tools mentioned, or if you have already given them a shot, I'm eager to hear about your experience. Whether it's a success story or you're facing challenges, your feedback is valuable to me.

By Maarten Van Steenkiste

As a pragmatic, self-taught Front-end Developer at Craftzing, I am driven to enhance efficiency through smart, innovative software solutions. I believe in the power of technology to make everyday tasks more easy and efficient for everyone.