This month is about working smarter. Get more impact from the content you’ve already created, and use a popular CLI tool to make some common Git tasks faster and easier to navigate.

When "Make Something New" Isn't the Best Strategy

Shipping new content feels great. You've put in the hours, polished it until it shines, and now it's live with your name on it. It feels good to create; it's what you're supposed to do, right? After all, you're a content creator.

Content creation feels safe. You love learning about new things, you love building demos, and you love that feeling of excitement that builds right before you send this great new piece out into the world. You want it to be successful, and your organization does too, so it's easy to get caught up placing bets on new content.

Every new piece is a gamble. Creating content takes days of research, drafting, and editing, and you won't know if it resonates until after it's published. When it flops, all that work looks like wasted money and time. Create too much new content that takes too long to create and underperforms, and your team looks like it's burning resources without results. That invites scrutiny, budget cuts, or even layoffs.

The solution is to be strategic about how you drive impact with your content. Remix and reuse the great things you've already created, and be intentional about making every new piece work harder for you.

Start with what you already have

You probably have a great back catalog of content, so the fastest way to amplify impact is to reuse your existing work. Repurposing lets you extend the life of a proven idea without the heavy lift of creating something new.

Content strategist Rebecca Lieb described this approach as the Thanksgiving turkey approach back in 2012. You roast one turkey for the holiday meal, but you don't stop there. You use the leftovers to make sandwiches, soup, and casseroles for days. Apply the same approach to your content strategy.

Find a blog post that gained traction and turn it into a narrated video walkthrough. Review a podcast episode or conference talk that resonated well and transcribe it into a blog post, or break it up into reels or shorts you share on various social platforms. Turn a strong tutorial into a workshop or even a "meetup in a box," a slide deck and talk track you can give to people to present at their user group on your behalf.

The work is lighter, the payoff is faster, and you reach people in new places.

Once you see the value of leftovers, the next step is to design your content for reuse from the start. Write your talk as a tutorial first so it can be published later. Record it to produce a video. Slice the video into clips for social platforms. And plan how each piece connects to the other pieces.

I've turned several of my conference talks into book drafts this way. When I produce a video, I write the whole script out first so I can publish a video and text version at the same time. When I develop courses, I plan for in-person, online, and hybrid delivery, as well as self-service and instructor-led training. And those courses are often composed of content I or others developed.

By planning ahead and thinking about reuse, you stop treating content as a one-off event. You start building pipelines and eventually deliver a system that keeps producing value.

There's an additional benefit to this approach that you might not have considered: presenting the same content different ways helps people learn.

Embrace multi-modal delivery

In Issue #10 I explained why learning styles are a myth. Matching content to supposed "styles" doesn't improve learning. But that doesn't mean format doesn't matter.

Research on Universal Design for Learning (UDL) shows that presenting information in multiple ways reduces barriers and helps more people engage. And when learners engage multiple senses, they're more likely to remember and develop a deeper understanding of the material.

Reusing your content isn't just about saving time and resources. It makes your ideas stickier and more accessible. I've had content that didn't perform well in one medium do exceptionally well in other formats. Sometimes it takes the right mix of content and medium to get that viral moment you're chasing.

Audit your archives to find what you can repackage. Then, on your next project, plan how you'll deliver that content in different ways. You'll get more reach, more retention, and more long-term value for your investment.

Things To Explore

• Obsidian introduced a new core plugin called Bases, which lets you turn a set of notes into a database.
• The 2025 StackOverflow Developer Survey is out, and it contains valuable information on how people are learning. Spoiler alert: people don't trust AI, and they prefer long-form written material over video. With over 43,000 responses, this is a pretty good snapshot of the developer industry, even if StackOverflow isn't as popular as it once was.

Improve Git Navigation with fzf

Using Git on the command-line interface can sometimes feel frustrating. Git makes you memorize branch names, copy and paste commit hashes, and you have to hope you don't type something wrong.

fzf is a "fuzzy finder" for your shell. You can use it to search your history, select a file to work on, or even integrate it with Vim to navigate your project. With fzf, you can add an interactive menu system to your Git workflow that lets you pick branches, commits, or stashes. And with Git's command aliases, you can create new Git commands that integrate fzf.

Install fzf

Before you start, make sure you have fzf installed.

On macOS, install with Homebrew:

brew install fzf

On Ubuntu/Debian, use apt:

sudo apt install fzf

On Fedora, use dnf:

sudo dnf install fzf

Or build from source:

git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install

If you used the GitHub installer, it will ask if you want to enable key bindings and completion. Otherwise, add the following to your shell configuration file.

For Bash, add this to ~/.bashrc on Linux or ~/.bash_profile on macOS:

[ -f ~/.fzf.bash ] && source ~/.fzf.bash

For zsh, add this to ~/.zshrc:

[ -f ~/.fzf.zsh ] && source ~/.fzf.zsh

Restart your shell, then run fzf --version to confirm it is available.

Now you'll use it to make a few Git-related tasks less complicated.

Check out branches and tags interactively

Switching branches in Git often means typing names from memory or scrolling through git branch output. It's error-prone and slow. With fzf, you can pick the branch you want from an instant menu.

To do this, you use command substitution.

The git checkout command needs a branch name, and you can list all the branches with git branch --all. If you pipe that output to the fzf command, you can use keyboard navigation and fuzzy searching to find the entry you need.

LearnGitBranching is a Git repository offering an interactive way to learn Git. It's also a good repository to use to demonstrate some new commands.

Clone this repo so you can try the commands in this article:

git clone https://github.com/pcottle/learnGitBranching.git demo-git

Now switch to the demo-git directory:

cd demo-git

Try the following command in your shell to use fzf to navigate the repository's branches:

git checkout $(git branch --all | fzf)

Command substitution runs the command inside the parentheses and substitutes its output into the surrounding command line. So you're running the inner command of git branch --all | fzf) and taking the result it gives and using it as the argument to git checkout.

When you enter the command, you get a searchable list of branches:

>   remotes/origin/skipIntroOnBuilder
    remotes/origin/revert-1112-main
    remotes/origin/pr-1204
    remotes/origin/noPrompts
    remotes/origin/main
    remotes/origin/gh-pages
    remotes/origin/attempt1245
    remotes/origin/HEAD -> origin/main
  * main
  9/9 

Type a few letters for the branch you want, then press Enter, and you've checked out the branch. Try checking out the gh-pages branch.

Now add this as an alias to your ~/.gitconfig file:

[alias]
  co = "!f() { git checkout $(git branch --all | fzf); }; f"

The leading ! runs a shell command instead of a direct git subcommand. f() defines a shell function called f. The function body contains the command, and the final f at the end of the line invokes the function.

Now you can run git co to switch branches interactively.

You can use this approach to check out a tag as well:

git checkout $(git tag | fzf)

Save this alias to ~/.gitconfig if you plan to use it often:

[alias]
  tco = "!f() { git checkout $(git tag | fzf); }; f"

You can use this approach to juggle in-progress work, too.

Manage Stashes

If you're a git stash power user, you know that managing multiple stashes is tedious, too. But you can use the same approach you used with branches and tags to select which stash to apply. Use git stash list with fzf:

git stash apply $(git stash list | fzf | cut -d: -f1)

This runs git stash list and passes the results to fzf. When you select a result, the result gets sent to the cut command to trim down the results. The -d: part tells cut to use spaces as the delimiter, and -f1 takes the first field, which is everything up to the delimiter. The resulting stash name gets sent back to git stash apply as its argument.

Most people use git stash without arguments, but if you get into the habit of naming your stashes with git stash push -m "detailed message", it'll be easier for you to manage your in-flight work.

Add an alias to ~/.gitconfig if you think you'll use this a lot:

[alias]
  sap = "!f() { git stash apply $(git stash list | fzf | cut -d: -f1); }; f"

Now you can use git sap to see a list of stashes and select one to apply it.

Cherry-pick without copy-paste

If you need to move a commit to a different branch, you'll use git cherry-pick, but this often means copying a SHA out of git log and pasting it into the git cherry-pick command.. With fzf, you can pick a commit by its message instead of a hash.

Run this command to send the commit log to fzf and parse out the result:

git cherry-pick $(git log --oneline | fzf | cut -d' ' -f1)

The git log --oneline command displays the six-digit version of the hash, followed by the commit message. The log gets passed to fzf. When you select a result, you use cut to grab just the hash, using a space delimiter and the first field.

fzf shows you a list of commits you can scroll through or search. Pick the commit you want, and Git applies it.

To save on keystrokes, add this alias to ~/.gitconfig:

[alias]
  pick = "!f() { git cherry-pick $(git log --oneline | fzf | cut -d' ' -f1); }; f"

Now you can use git pick instead.

Each of these shortcuts replaces scrolling, copy-pasting, and typo-prone commands with an interactive picker.

My book Small, Sharp Software Tools covers command substitution, cut, fzf, and many other tools like this in more detail.

Parting Thoughts

Here are some things to consider and try before the next issue:

1. What other ways can you think of using fzf with Git? And what other ways can you work fzf into your other command-line tool workflows?
2. Identify three pieces of content you've created this year. How can you reuse them?
3. Challenge yourself to deliver content in a medium you're less comfortable with.

Until next time...

I'd love to talk with you about this newsletter on Mastodon, Twitter, or LinkedIn. Let's connect!

Please support this newsletter and my work by encouraging others to subscribe or by buying a friend a copy of Exercises for Programmers, Small, Sharp Software Tools, or any of my other books.