Josh Medeski

Tuning Your Claude Code Settings

Mon, 20 Jul 2026 12:00:00 GMT

A short guide to the Claude Code settings I've changed, why I changed them, and the community tips I evaluated but skipped.

The Case for Breaks in the AI Era

Fri, 29 May 2026 12:00:00 GMT

The science on why rest, sleep, and hobbies aren't slacking — they're the highest-leverage move you have in the AI era.

The Hidden Cost of Node.js Flexibility

Wed, 28 Jan 2026 15:00:00 GMT

ReferenceError: someFunction is not defined

That error haunted me for weeks. It showed up intermittently in our Vitest runs - sometimes tests passed, sometimes they didn’t. No code changes between runs. Just… chaos.

After more debugging than I’d like to admit, I found the culprit: circular dependencies.

Node.js Doesn’t Care (Until It Does)

Here’s the thing about Node.js - it’s incredibly permissive. You can create modules and import them in any direction you want. Module A imports Module B? Fine. Module B imports Module A right back? Also fine. No warnings, no errors at build time.

Until your test runner loads modules in a slightly different order and suddenly a function that should exist… doesn’t.

The real gut punch came when I ran madge on our codebase:

npx madge --circular --extensions ts src/

Hundreds. Hundreds of circular dependencies.

The Order Problem

The reason these failures are intermittent comes down to module loading order. Imagine three modules with circular dependencies. When your test runner loads userService.test.ts, it might resolve dependencies in order X→Y→Z. But when it loads billingService.test.ts, those same underlying modules might load in order Y→X→Z.

In a circular dependency, that order difference determines whether an export is defined or undefined at the exact moment it’s accessed. Same code, different execution path, different result.

Why This Happens

It’s not always bad code. Sometimes it’s just… reality.

At nutiliti, we work with bills and houses. Bills belong to houses. But houses also have bills. The domain relationships are genuinely circular. When you’re modeling real-world concepts, clean one-directional dependencies aren’t always possible.

But more often, circular dependencies sneak in through:

Barrel files. Those convenient index.ts files that re-export everything from a directory. Your tsconfig might even auto-suggest the barrel import instead of the direct file. You import from @/features/billing instead of @/features/billing/calculateTotal, and suddenly you’ve pulled in the entire module graph.

Organic growth. Developer A adds a utility to Module X. Developer B needs that utility in Module Y, which Module X already imports. Quick fix: import it anyway. The cycle is born.

Convenience over structure. It’s faster to import what you need from wherever it exists than to think about whether that import makes architectural sense.

But It Works in Production…

If circular dependencies are such a problem, why does the application run fine in production?

Because your production environment is hiding the fragility.

Traditional build tools - a simple tsc compile, legacy bundlers, straightforward Node.js execution - load modules synchronously in a deterministic order. They figure out an order that works and stick with it. Every deploy, same order, same result.

Modern tooling doesn’t give you that safety net. Vitest, built on Vite’s philosophy of native ESM and on-demand module loading, isolates each test file with its own module context. Modules load lazily as tests request them. That isolation means each test can stumble into a different - and potentially broken - loading order.

Vitest became our canary in the coal mine. The intermittent test failures weren’t a bug in the test runner. They were revealing fragility that our production environment happened to hide.

This matters beyond testing. If you want to adopt modern build systems - faster bundlers, better treeshaking, improved hot module replacement - circular dependencies become a blocker. The tools that enable those features also enable the chaos. Addressing circular dependencies isn’t just about fixing flaky tests. It’s about keeping your options open for the future.

What Good Actually Looks Like

I know strict dependency injection is possible because I’ve done it - just not in Node.js.

Sesh is a terminal session manager I built in Go. When I rewrote it for version 2, I used the dependency injection patterns that Go’s ecosystem actively encourages. The architecture has four distinct layers:

CLI Layer (commands, flags, user interaction)
    ↓
Domain Layer (lister, connector, namer - core business logic)
    ↓
Integration Layer (tmux, zoxide, git wrappers)
    ↓
Wrapper Layer (execwrap, oswrap - system abstractions)

Dependencies flow in one direction: down. The CLI layer depends on the domain layer, which depends on integrations, which depend on wrappers. Never the reverse. All instantiation happens in one place, with constructor functions wiring everything together.

The result? Exhaustive mocking. Structured unit tests for every piece of the application. When I need to test the Connector, I inject mock implementations of Tmux and Zoxide. The boundaries are crystal clear.

But here’s the uncomfortable truth: this required a complete rewrite.

Version 1 of Sesh wasn’t architected this way. Getting to this level of structure meant starting over with the pattern in mind from day one. Go’s community expects this approach - interfaces, constructor injection, clear layer boundaries. The language and tooling reinforce it.

Node.js doesn’t.

The Gap Between Ideal and Reality

What I learned from Sesh is that other communities do care about this. They have real solutions. But those solutions require either:

Starting with strict patterns from the beginning, or
Committing to a significant rewrite

In a real-world Node.js codebase with multiple developers, competing business goals, and years of organic growth? Expecting that level of organization is… unlikely. Not impossible. But unlikely.

The pressure to ship features will always conflict with the desire for architectural cleanliness. And unlike Go, nothing in the Node.js ecosystem pushes back when you take the convenient path.

The Compounding Problem

Here’s what made this genuinely difficult: I couldn’t just fix it.

With hundreds of existing circular dependencies, I couldn’t enable any tooling that would block new ones. No ESLint rule, no pre-commit hook. Every new PR would fail against issues that predated it.

So while I worked through the backlog with madge, new developers were unknowingly creating more cycles. Two steps forward, one step back.

Tools that can help:

madge - Visualize and detect circular dependencies
vite-plugin-circular-dependency - Catch cycles in your Vite build
ESLint import/no-cycle - Block new cycles (once you’ve cleared existing ones)

The Actual Fix: Think Top-Down

The solution isn’t a tool. It’s a mental model.

Dependency injection. Understanding which code depends on which. Always passing dependencies down, never reaching back up.

Think of your codebase as a tree. Data flows from trunk to branches to leaves. A leaf can use what the branch provides, but it should never reach back to grab something from the trunk directly.

In practice:

Core utilities at the bottom, imported by everything, importing nothing domain-specific
Domain modules in the middle, importing utilities, exporting to features
Features at the top, importing from domains, never imported by them

When you’re about to add an import, ask: “Am I reaching up or down?”

What I Haven’t Solved

I’ll be honest - the barrel file problem still bites us.

TypeScript’s auto-import suggestions often prefer the index.ts path over the direct file path. It’s more convenient, the import looks cleaner. But it pulls in more than you need and dramatically increases cycle risk.

I don’t have a great answer yet. We’re experimenting with being more intentional about what barrel files export, but it’s friction against developer convenience.

Some problems don’t have clean solutions. You just… manage them.

The Takeaway

Node.js gives you freedom. That freedom has a cost.

If your tests are failing intermittently with bizarre “not defined” errors, check for circular dependencies. If you find some, assume there are more. And if you’re starting a new project, set up detection before the cycles accumulate.

The best time to prevent circular dependencies was at project start. The second best time is now - before that number grows from dozens to hundreds.

How To Use Git Worktrees to Switch Contexts Quickly and Easily

Mon, 05 Jan 2026 18:00:00 GMT

Git Worktrees have become an invaluable piece of my workflow. They allow me to switch between contexts quickly and easily, isolate breaking changes, and do code reviews without disrupting my current work. In this post, I’m going to break down how I set up my Git Worktrees and how I use them to stay productive.

Why Use Git Worktrees?

Not every repository needs to be using the worktree system. If a project is simple, strictly for research, or something you visit only once in a blue moon, the standard structure works fine. However, you should consider worktrees if you:

Do code reviews: You need to check out other people’s branches frequently without messing up your current state.
Handle breaking changes: You work on dependency upgrades or architecture changes that are hard to switch back and forth from.
Work in Monorepos: You have sub-projects within one repo and want to isolate specific areas of code.
Context switch often: You are patching production, doing hotfixes, or working on multiple branches throughout the same day with incomplete states.

If you are a full-time programmer, you will likely find worktrees beneficial for managing these different areas of responsibility seamlessly.

My friend, Nick Nisi, has an in-depth guide that I recommend reading as well. Let’s get into my specific setup and how I use Git Worktrees in my daily workflow. I will cover how I set up the directory structure, how I create worktrees, and how I manage branches and sessions with tools like Sesh, GH Dash, Octo, and Treekanga to optimize my workflow.

By the end of this post, you should have a clear understanding of how to implement Git Worktrees in your own projects effectively. Let’s dive in!

Setting Up the Directory Structure

First, decide where to clone repositories. I keep it simple with a directory called C (for code) in my home directory. When creating worktrees, I recommend creating a parent folder with a simplified name for the project.

For example, for my project Sesh, I would run:

cd ~/c
mkdir sesh
cd sesh

Inside this directory, I clone the repository as a bare repo. I prefer naming the folder .git rather than .bare to keep it consistent with standard Git conventions.

git clone --bare <repo-url> .git

Tip: Cleaner shell history

If you replace the URL contents by evaluating pbpaste (for macOS), it will paste the URL directly from your clipboard without adding extra characters or formatting that can clutter your shell history. This keeps your command history clean and makes it easier to reuse commands in the future.

git clone --bare $(pbpaste) .git # zsh bash
git clone --bare (pbpaste) .git # fish

Creating Worktrees

Once cloned, you will see that the .git folder contains hooks, info, refs, config, etc. To create the actual working directories, you use the worktree command:

git worktree add main

This creates a folder named main where that branch lives. You can create additional worktrees for specific features or versions, such as:

git worktree add tui
git worktree add v1

Naming Conventions and Branch Management

I like to have a dedicated worktree called review specifically for code reviews.

One limitation to note is that you cannot check out the same branch twice in a worktree environment. If you try to check out main in your review folder while it is checked out in your main folder, Git will throw an error.

To get around this, I often create a branch called _main. This allows me to fetch the latest changes or reference the main branch without conflicting with the actual main worktree.

I also avoid using the worktree name as the branch name for complex features. Instead, I name worktrees based on the area of responsibility, such as:

ui (for a UI package)
pm-portal (for a specific area of the business)
add-bill-page (for a large feature requiring multiple PRs)

Optimizing Your Workflow with Tools

Session Management with Sesh

I use Sesh to manage my Tmux sessions. It easily identifies the parent folder structure we set up.

When I select sesh main, the session is named sesh/main.
I can jump to sesh/tui or sesh/review instantly.
In monorepos, I can target specific sub-projects.

Code Reviews with GH Dash and Octo

For reviews, I use gh-dash, a terminal UI for GitHub issues and PRs. I configure gh-dash by adding the following entry to my config:

repoPaths:
  joshmedeski/sesh: ~/c/sesh/review

In my Sesh config, I set up a specific session for reviews:

[[session]]
name = "sesh reviews"
path = "~/C/sesh/review"
startup_command = "gh dash"

I also use a tool called Octo with custom keybindings. If I press Shift+O, it opens the PR in Octo, where I can see comments, add reviews, and manage the PR, all within the review worktree.

Cleaning Up with Treekanga

One downside of worktrees is that they can bloat your hard drive, similar to cloning a project multiple times (especially with node_modules). It is important to prune your work when features are complete.

I use a tool called Treekanga to help with this. You can configure it to recognize your bare repo structure.

repos:
  sesh:
    defaultBranch: main
    worktreeTargetDir: /c/sesh
    listDisplayMode: directory
    bareRepoName: .git

Treekanga allows you to list your worktrees and use a delete command to delete stale or orphaned branches that are no longer needed.

treekanga delete --stale

Conclusion

Worktrees have changed my relationship with Git. They make it less frustrating to handle complex workflows, dependency updates, and frequent context switching. While I still use standard clones for simple repositories, worktrees are my go-to for big projects and complicated work sets.

Start simple, build the muscle memory, and give it a try.

Instantly Open Any Website Using Raycast

Tue, 20 May 2025 21:00:00 GMT

Using an open-source search engine and Raycast, I can get to any website I want instantly. In this post, I’ll show you how it works and why it’s changed the way I browse the web.

SearchXNG

The search engine I use is called SearXNG. It’s open-source and runs as a Docker container on your machine. You simply forward port 8080, and you’re ready to go.

See the SearXNG Docker Container instructions for how to set it up.

For example, if you search for GitHub NeoVim, you’d expect the first result to be github.com/neovim/neovim. This works for a variety of queries:

Searching my own name, “joshmedeski”, puts my website first.
Searching for “joshmedeski blazing fast window management” brings up my blog post as the top result.
Typing in “imdb andor” quickly brings up the IMDB page for the TV show, Andor.

Leveraging Search Engine Skills

Most of us use search engines every day and have developed a sense for what results our keywords will produce. When you know you always want the first result, many search engines offer a “get lucky” feature—essentially rolling the dice to jump straight to the top hit.

Introducing “Bangs” and Auto Redirects

A key part of this workflow is the use of bangs. DuckDuckGo popularized the concept with exclamation points that redirect your search to specific sites.

But SearXNG takes it further with a double bang auto redirect. When you use !! at the start of your query, you’re automatically redirected to the first result.

Example Searches

!! GitHub NeoVim → Instantly opens the NeoVim GitHub page.
!! Paris France → Redirects to the Wikipedia entry for France.

Even if the first result isn’t perfect, it’s almost always contextual and relevant.

Setting Up with Raycast

Here’s how I have it configured:

Create a quicklink in Raycast with the following URL:

http://localhost:8080/search?q=!!%20{argument name="term"}

Double bangs (!!) trigger the auto-redirect.
The search engine runs locally on localhost:8080.
The API endpoint is /search.
The query includes !! and the search term as arguments, which you can pass into Raycast.

When I type !! and hit tab, Raycast prompts for the term. I enter what I want, and ARC gives me a preview window with the result.

Supercharging with a Keyboard Shortcut

I took it a step further by binding the command to ⌥ + 1. Since the exclamation point is on the 1 key, it’s a fast, muscle-memory shortcut to trigger a search.

Now, I just type the shortcut, enter my keywords, and instantly jump to the page I want—like T-Mux’s documentation or any other site.

Why This Workflow Works for Me

No need for bookmarks: If I know what I want, I can get to it with keywords.
Minimal management: I don’t have to organize or maintain anything.
Accuracy: I rarely end up on irrelevant pages.
Efficiency: This method is fast, smart, and leverages my existing search skills.

Traditional search engines have almost disappeared from my workflow. For research-heavy browsing, I use a different tool (which I’ll cover in a future post).

That’s an overview of how I use “searching” and Raycast together to instantly redirect to any website.

I made my favorite tmux feature better with sesh

Mon, 24 Mar 2025 22:00:00 GMT

I made one of my favorite tmux sessions even better, so let’s talk about it.

tmux last command

So let’s talk about the last command. It is bound to <prefix> capital L and it allows you to switch the attached client back to the last session.

So think of this like a command tab kind of feature, but for tmux. So if I was to open up a second session and we were to hit <prefix> capital L, you’ll see that I’ll be able to switch very easily back to the previous session.

macOS keybinding

I have done an extra step here and I have bound this to command L. And if you want to know about how I did that, I have a video all about how I can bind macOS key bindings to tmux. And so this is fantastic. Maybe I’m working on the front end and the back end of something and I want to have two sessions open and quickly switch between them. Or maybe I’m messing with my configs, right? And I want to play around with that.

The problem

However, this starts to quickly fall apart when there’s a third introduced. And so now my workflow is I want to be able to quickly and easily close a tmux session. And then there’s this detach on destroy feature that’s really helpful.

set -g detach-on-destroy off # don't exit from tmux when closing a session

So if I’m in neovim and I decide I don’t want it anymore, I can close the final window. And when I do that, the last command actually stops working. You see that when I hit ⌘+l, it says can’t find last session. And so the feature sort of falls apart very quickly as soon as you start closing sessions, right? And so the way to fix that is you can switch back to one of the other sessions manually and then the feature comes back. And that’s all right. But further it falls apart when we detach and we reattach. And so if we detach from a tmux session and come back, the idea of last goes away in tmux mind. And so you’ll see that this feature still doesn’t work. Can’t find last session.

And so I thought, hey, you know, we know the attached order with the timestamp from tmux. tmux stores that data and tells us when we’ve attached to something for every session forever. It’s one of those things that they have the information, but they’re choosing not to use it with this command. And so I decided, hey, it doesn’t work right now, right? Can’t find last session.

Introducing `sesh last`

However, if I was to type sesh last, I was able to solve the problem. And so now sesh last can switch to the previous session no matter what it is. And now if I was to have a third session, I was to close it, right? Then I can do sesh last and it’s able to switch to back to fish. And so you can see pretty easily this thing works as you’d expect it to. And the way that you end up binding it, it’s sort of up to you. But I recommend that you just overwrite the default behavior.

bind -N "⌘+l last-session (via sesh) " L run-shell "sesh last || tmux display-message -d 1000 'Only one session'"

And so you use the bind command in your tmux config. It’s called run shell and you can run shell. You can say sesh last. And then optionally, I like this. You can have this double, this double pipe for or and you can say, you know, if sesh last fails, basically it’s because there’s only one session. And so I’ll show you really quickly how that works. But basically when you make this kind of change, usually it’s best to restart tmux. So we’ll go ahead and kill it and restart it.

And then we’ll reopen it up. And you’ll see the fallback where only one session, that makes sense. But if I open up more than one, right, it works as expected. And if I open up a third and was to close it, I’m still able to switch back. And if I was to detach and reattach, the feature still works.

In conclusion

And so this has been a huge time saver for me. I really love this feature. I just wanted it to always work. I haven’t yet taken the time to contribute to the tmux source code. And so I just decided to extend my tmux session manager to include this feature.

And so if you’re not using it already, I highly recommend you take a look at my video on sesh and how it works and all of its inner workings. This is a new feature, so I wanted to show it off. And I hope that you use the last command more and let me know if there’s anything else that you want to know about this workflow.

AI in Neovim (NeovimConf 2024)

Tue, 19 Nov 2024 00:00:00 GMT

Discover how AI plugins using LLMs are transforming Neovim into a cutting-edge tool for developers. This talk will explore the latest AI-powered plugins and integrations that enhance coding efficiency, streamline workflows, and elevate your development experience. Whether you’re a seasoned Neovim user or new to the editor, learn how AI can revolutionize your coding practices and prepare you for the future of software development.

Completion

Code completion is a feature in which the editor suggests completions for the current word or symbol. This can be helpful for writing code faster and with fewer errors. There are many plugins available for code completion in Neovim.

My Choice

github/copilot.vim

Neovim plugin for GitHub Copilot

Alternatives

zbirenbaum/copilot-cmp

Lua plugin to turn github copilot into a cmp source

codota/tabnine-nvim

Tabnine Client for Neovim

Exafunction/codeium.nvim

A native neovim extension for Codeium

milanglacier/minuet-ai.nvim

Dance with Intelligence in Your Code. Minuet offers code completion as-you-type from popular LLMs including OpenAI, Gemini, Claude, Ollama, Llama.cpp, Codestral, and more.

Configuration

return {
  "github/copilot.vim",
  dependencies = { "catppuccin/nvim" },
  event = "VimEnter",
  init = function()
    vim.g.copilot_no_tab_map = false
    vim.g.copilot_workspace_folders = { vim.fn.getcwd() }
  end,
  keys = {},
}

Chat

AI Chat in the editor is a feature that allows you to chat with an AI assistant directly in your editor. This can be helpful for generating code snippets, writing documentation, or even just having a conversation.

My Choice

CopilotC-Nvim/CopilotChat.nvim

Chat with GitHub Copilot in Neovim

Alternatives

yetone/avante.nvim

Use your Neovim like using Cursor AI IDE!

jackMort/ChatGPT.nvim

ChatGPT Neovim Plugin: Effortless Natural Language Generation with OpenAI's ChatGPT API

Configuration

return {
  "CopilotC-Nvim/CopilotChat.nvim",
  -- NOTE: configured via LazyVim 💤
  -- https://www.lazyvim.org/extras/ai/copilot-chat
}

Generation

AI code generation is a feature that allows you to generate code snippets using AI models. This can be helpful for writing code faster and with fewer errors.

My Choice

robitx/gp.nvim

Alternatives

David-Kunz/gen.nvim

Neovim plugin to generate text using LLMs with customizable prompts

gsuuon/model.nvim

Neovim plugin for interacting with LLM's and building editor integrated prompts.

Configuration

return {
  "robitx/gp.nvim",
  name = "gp",
  event = "BufEnter",
  config = function()
    require("gp").setup({
      openai_api_key = os.getenv("OPENAI_API_KEY"),
      providers = {
        anthropic = {
          endpoint = "https://api.anthropic.com/v1/messages",
          secret = os.getenv("ANTHROPIC_API_KEY"),
        },
        copilot = {
          endpoint = "https://api.githubcopilot.com/chat/completions",
          secret = {
            "bash",
            "-c",
            "cat ~/.config/github-copilot/hosts.json | sed -e 's/.*oauth_token...//;s/\".*//'",
          },
        },
        ollama = {
          endpoint = "http://localhost:11434/v1/chat/completions",
        },
        openai = {
          endpoint = "https://api.openai.com/v1/chat/completions",
          secret = vim.fn.getenv("OPENAI_API_KEY"),
        },
      },
      whisper = {
        -- you can disable whisper completely by whisper = {disable = true}
        disable = false,

        -- OpenAI audio/transcriptions api endpoint to transcribe audio to text
        endpoint = "https://api.openai.com/v1/audio/transcriptions",
        -- directory for storing whisper files
        store_dir = (os.getenv("TMPDIR") or os.getenv("TEMP") or "/tmp") .. "/gp_whisper",
        -- multiplier of RMS level dB for threshold used by sox to detect silence vs speech
        -- decibels are negative, the recording is normalized to -3dB =>
        -- increase this number to pick up more (weaker) sounds as possible speech
        -- decrease this number to pick up only louder sounds as possible speech
        -- you can disable silence trimming by setting this a very high number (like 1000.0)
        silence = "1.75",
        -- whisper tempo (1.0 is normal speed)
        tempo = "1.75",
        -- The language of the input audio, in ISO-639-1 format.
        language = "en",
        -- command to use for recording can be nil (unset) for automatic selection
        -- string ("sox", "arecord", "ffmpeg") or table with command and arguments:
        -- sox is the most universal, but can have start/end cropping issues caused by latency
        -- arecord is linux only, but has no cropping issues and is faster
        -- ffmpeg in the default configuration is macos only, but can be used on any platform
        -- (see https://trac.ffmpeg.org/wiki/Capture/Desktop for more info)
        -- below is the default configuration for all three commands:
        -- whisper_rec_cmd = {"sox", "-c", "1", "--buffer", "32", "-d", "rec.wav", "trim", "0", "60:00"},
        -- whisper_rec_cmd = {"arecord", "-c", "1", "-f", "S16_LE", "-r", "48000", "-d", "3600", "rec.wav"},
        -- whisper_rec_cmd = {"ffmpeg", "-y", "-f", "avfoundation", "-i", ":0", "-t", "3600", "rec.wav"},
        rec_cmd = nil,
      },
      agents = {
        {
          name = "Qwen2.5:32b",
          chat = true,
          command = true,
          provider = "ollama",
          model = { model = "qwen2.5:32b" },
          system_prompt = "I am an AI meticulously crafted to provide programming guidance and code assistance. "
            .. "To best serve you as a computer programmer, please provide detailed inquiries and code snippets when necessary, "
            .. "and expect precise, technical responses tailored to your development needs.\n",
        },
        {
          name = "Codellama",
          chat = true,
          command = true,
          provider = "ollama",
          model = { model = "codellama" },
          system_prompt = "I am an AI meticulously crafted to provide programming guidance and code assistance. "
            .. "To best serve you as a computer programmer, please provide detailed inquiries and code snippets when necessary, "
            .. "and expect precise, technical responses tailored to your development needs.\n",
        },
        {
          name = "ChatGPT4",
          chat = true,
          command = false,
          -- string with model name or table with model name and parameters
          model = { model = "gpt-4-1106-preview", temperature = 1.1, top_p = 1 },
          -- system prompt (use this to specify the persona/role of the AI)
          system_prompt = "You are a general AI assistant.\n\n"
            .. "The user provided the additional info about how they would like you to respond:\n\n"
            .. "- If you're unsure don't guess and say you don't know instead.\n"
            .. "- Ask question if you need clarification to provide better answer.\n"
            .. "- Think deeply and carefully from first principles step by step.\n"
            .. "- Zoom out first to see the big picture and then zoom in to details.\n"
            .. "- Use Socratic method to improve your thinking and coding skills.\n"
            .. "- Don't elide any code from your output if the answer requires coding.\n"
            .. "- Take a deep breath; You've got this!\n",
        },
        {
          name = "CodeGPT4",
          chat = false,
          command = true,
          -- string with model name or table with model name and parameters
          model = { model = "gpt-4-1106-preview", temperature = 0.8, top_p = 1 },
          -- system prompt (use this to specify the persona/role of the AI)
          system_prompt = "You are an AI working as a code editor.\n\n"
            .. "Please AVOID COMMENTARY OUTSIDE OF THE SNIPPET RESPONSE.\n"
            .. "START AND END YOUR ANSWER WITH:\n\n```",
        },
        {
          name = "Claude3Haiku",
          chat = true,
          command = true,
          provider = "anthropic",
          model = { model = "claude-3-haiku-20240307" },
          system_prompt = "You are a general AI assistant.\n\n"
            .. "The user provided the additional info about how they would like you to respond:\n\n"
            .. "- If you're unsure don't guess and say you don't know instead.\n"
            .. "- Ask question if you need clarification to provide better answer.\n"
            .. "- Think deeply and carefully from first principles step by step.\n"
            .. "- Zoom out first to see the big picture and then zoom in to details.\n"
            .. "- Use Socratic method to improve your thinking and coding skills.\n"
            .. "- Don't elide any code from your output if the answer requires coding.\n"
            .. "- Take a deep breath; You've got this!\n",
        },
      },
      hooks = {
        -- example of usig enew as a function specifying type for the new buffer
        CodeReview = function(gp, params)
          local template = "I have the following code from {{filename}}:\n\n"
            .. "```{{filetype}}\n{{selection}}\n```\n\n"
            .. "Please analyze for code smells and suggest improvements."
          local agent = gp.get_chat_agent()
          gp.Prompt(params, gp.Target.enew("markdown"), agent, template)
        end,
        -- example of making :%GpChatNew a dedicated command which
        -- opens new chat with the entire current buffer as a context
        BufferChatNew = function(gp, _)
          -- call GpChatNew command in range mode on whole buffer
          vim.api.nvim_command("%" .. gp.config.cmd_prefix .. "ChatNew")
        end,
        ReactIconSvg = function(gp, params)
          local buf = vim.api.nvim_get_current_buf()
          local lines = vim.api.nvim_buf_get_lines(buf, 0, -1, false)
          local content = table.concat(lines, "\n")
          local template = "The following SVG code needs to be converted into a valid React component:\n\n"
            .. "INPUT:\n"
            .. "```tsx\n"
            .. content
            .. "```\n\n"
            .. "  - Remove the `width` and `height` props from the `<svg>` element\n"
            .. "  - Add `{...props}` to the bottom of the `<svg>` element\n"
            .. "  - Replace all `fill` values with `currentColor`\n"
            .. "  - Replace all props that are dash-separated (ex: `fill-rule`) with camelCase (ex: `fillRule`)\n"
            .. "  - Don't remove any other props or attributes\n"
            .. "  - Preserve the indentation rules\n"
            .. "  - Only include the code snippet, no additional context or explanation is needed."
          local agent = gp.get_command_agent()
          gp.logger.info("Updating React SVG: " .. agent.name)
          gp.Prompt(params, gp.Target.rewrite, agent, template, nil)
        end,
        UiIconExport = function(gp, params)
          local template = "The following React modules need to be refactored and properly exported:\n\n"
            .. "```tsx\n{{selection}}\n```\n\n"
            .. "  - Take the unused import at the bottom of the file and move it up to the other imports in the alphabetical orrder\n"
            .. "  - Export the unsed import in the `icons` array in alphabetical order\n"
            .. "  - Export the unsed import in the `export {` object in alphabetical order\n"
            .. "  - Only include the code snippet, no additional context or explanation is needed."
          local agent = gp.get_command_agent()
          gp.logger.info("Updating React SVG: " .. agent.name)
          gp.Prompt(params, gp.Target.rewrite, agent, template, nil)
        end,
      },
    })
  end,

  keys = function()
    require("which-key").add({
      -- VISUAL mode mappings
      -- s, x, v modes are handled the same way by which_key
      {
        mode = { "v" },
        nowait = true,
        remap = false,
        { "<C-g><C-t>", ":<C-u>'<,'>GpChatNew tabnew<cr>", desc = "ChatNew tabnew", icon = "󰗋" },
        { "<C-g><C-v>", ":<C-u>'<,'>GpChatNew vsplit<cr>", desc = "ChatNew vsplit", icon = "󰗋" },
        { "<C-g><C-x>", ":<C-u>'<,'>GpChatNew split<cr>", desc = "ChatNew split", icon = "󰗋" },
        { "<C-g>a", ":<C-u>'<,'>GpAppend<cr>", desc = "Visual Append (after)", icon = "󰗋" },
        { "<C-g>b", ":<C-u>'<,'>GpPrepend<cr>", desc = "Visual Prepend (before)", icon = "󰗋" },
        { "<C-g>c", ":<C-u>'<,'>GpChatNew<cr>", desc = "Visual Chat New", icon = "󰗋" },
        { "<C-g>g", group = "generate into new ..", icon = "󰗋" },
        { "<C-g>ge", ":<C-u>'<,'>GpEnew<cr>", desc = "Visual GpEnew", icon = "󰗋" },
        { "<C-g>gn", ":<C-u>'<,'>GpNew<cr>", desc = "Visual GpNew", icon = "󰗋" },
        { "<C-g>gp", ":<C-u>'<,'>GpPopup<cr>", desc = "Visual Popup", icon = "󰗋" },
        { "<C-g>gt", ":<C-u>'<,'>GpTabnew<cr>", desc = "Visual GpTabnew", icon = "󰗋" },
        { "<C-g>gv", ":<C-u>'<,'>GpVnew<cr>", desc = "Visual GpVnew", icon = "󰗋" },
        { "<C-g>i", ":<C-u>'<,'>GpImplement<cr>", desc = "Implement selection", icon = "󰗋" },
        { "<C-g>n", "<cmd>GpNextAgent<cr>", desc = "Next Agent", icon = "󰗋" },
        { "<C-g>p", ":<C-u>'<,'>GpChatPaste<cr>", desc = "Visual Chat Paste", icon = "󰗋" },
        { "<C-g>r", ":<C-u>'<,'>GpRewrite<cr>", desc = "Visual Rewrite", icon = "󰗋" },
        { "<C-g>s", "<cmd>GpStop<cr>", desc = "GpStop", icon = "󰗋" },
        { "<C-g>t", ":<C-u>'<,'>GpChatToggle<cr>", desc = "Visual Toggle Chat", icon = "󰗋" },
        { "<C-g>w", group = "Whisper", icon = "󰗋" },
        { "<C-g>wa", ":<C-u>'<,'>GpWhisperAppend<cr>", desc = "Whisper Append", icon = "󰗋" },
        { "<C-g>wb", ":<C-u>'<,'>GpWhisperPrepend<cr>", desc = "Whisper Prepend", icon = "󰗋" },
        { "<C-g>we", ":<C-u>'<,'>GpWhisperEnew<cr>", desc = "Whisper Enew", icon = "󰗋" },
        { "<C-g>wn", ":<C-u>'<,'>GpWhisperNew<cr>", desc = "Whisper New", icon = "󰗋" },
        { "<C-g>wp", ":<C-u>'<,'>GpWhisperPopup<cr>", desc = "Whisper Popup", icon = "󰗋" },
        { "<C-g>wr", ":<C-u>'<,'>GpWhisperRewrite<cr>", desc = "Whisper Rewrite", icon = "󰗋" },
        { "<C-g>wt", ":<C-u>'<,'>GpWhisperTabnew<cr>", desc = "Whisper Tabnew", icon = "󰗋" },
        { "<C-g>wv", ":<C-u>'<,'>GpWhisperVnew<cr>", desc = "Whisper Vnew", icon = "󰗋" },
        { "<C-g>ww", ":<C-u>'<,'>GpWhisper<cr>", desc = "Whisper", icon = "󰗋" },
        { "<C-g>x", ":<C-u>'<,'>GpContext<cr>", desc = "Visual GpContext", icon = "󰗋" },
      },

      -- NORMAL mode mappings
      {
        mode = { "n" },
        nowait = true,
        remap = false,
        { "<C-g><C-t>", "<cmd>GpChatNew tabnew<cr>", desc = "New Chat tabnew" },
        { "<C-g><C-v>", "<cmd>GpChatNew vsplit<cr>", desc = "New Chat vsplit" },
        { "<C-g><C-x>", "<cmd>GpChatNew split<cr>", desc = "New Chat split" },
        { "<C-g>a", "<cmd>GpAppend<cr>", desc = "Append (after)" },
        { "<C-g>b", "<cmd>GpPrepend<cr>", desc = "Prepend (before)" },
        { "<C-g>c", "<cmd>GpChatNew<cr>", desc = "New Chat" },
        { "<C-g>f", "<cmd>GpChatFinder<cr>", desc = "Chat Finder" },
        { "<C-g>g", group = "generate into new .." },
        { "<C-g>ge", "<cmd>GpEnew<cr>", desc = "GpEnew" },
        { "<C-g>gn", "<cmd>GpNew<cr>", desc = "GpNew" },
        { "<C-g>gp", "<cmd>GpPopup<cr>", desc = "Popup" },
        { "<C-g>gt", "<cmd>GpTabnew<cr>", desc = "GpTabnew" },
        { "<C-g>gv", "<cmd>GpVnew<cr>", desc = "GpVnew" },
        { "<C-g>n", "<cmd>GpNextAgent<cr>", desc = "Next Agent" },
        { "<C-g>r", "<cmd>GpRewrite<cr>", desc = "Inline Rewrite" },
        { "<C-g>s", "<cmd>GpStop<cr>", desc = "GpStop" },
        { "<C-g>t", "<cmd>GpChatToggle<cr>", desc = "Toggle Chat" },
        { "<C-g>w", group = "Whisper", icon = "󰗋" },
        { "<C-g>wa", "<cmd>GpWhisperAppend<cr>", desc = "[W]hisper [A]ppend" },
        { "<C-g>wb", "<cmd>GpWhisperPrepend<cr>", desc = "[W]hisper [P]repend" },
        { "<C-g>we", "<cmd>GpWhisperEnew<cr>", desc = "[W]hisper Enew" },
        { "<C-g>wn", "<cmd>GpWhisperNew<cr>", desc = "[W]hisper New" },
        { "<C-g>wp", "<cmd>GpWhisperPopup<cr>", desc = "[W]hisper Popup" },
        { "<C-g>wr", "<cmd>GpWhisperRewrite<cr>", desc = "[W]hisper Inline Rewrite" },
        { "<C-g>wt", "<cmd>GpWhisperTabnew<cr>", desc = "[W]hisper Tabnew" },
        { "<C-g>wv", "<cmd>GpWhisperVnew<cr>", desc = "[W]hisper Vnew" },
        { "<C-g>ww", "<cmd>GpWhisper<cr>", desc = "[W]hisper" },
        { "<C-g>x", "<cmd>GpContext<cr>", desc = "Toggle GpContext" },
      },

      -- INSERT mode mappings
      {
        mode = { "i" },
        nowait = true,
        remap = false,
        { "<C-g><C-t>", "<cmd>GpChatNew tabnew<cr>", desc = "New Chat tabnew" },
        { "<C-g><C-v>", "<cmd>GpChatNew vsplit<cr>", desc = "New Chat vsplit" },
        { "<C-g><C-x>", "<cmd>GpChatNew split<cr>", desc = "New Chat split" },
        { "<C-g>a", "<cmd>GpAppend<cr>", desc = "Append (after)" },
        { "<C-g>b", "<cmd>GpPrepend<cr>", desc = "Prepend (before)" },
        { "<C-g>c", "<cmd>GpChatNew<cr>", desc = "New Chat" },
        { "<C-g>f", "<cmd>GpChatFinder<cr>", desc = "Chat Finder" },
        { "<C-g>g", group = "generate into new .." },
        { "<C-g>ge", "<cmd>GpEnew<cr>", desc = "GpEnew" },
        { "<C-g>gn", "<cmd>GpNew<cr>", desc = "GpNew" },
        { "<C-g>gp", "<cmd>GpPopup<cr>", desc = "Popup" },
        { "<C-g>gt", "<cmd>GpTabnew<cr>", desc = "GpTabnew" },
        { "<C-g>gv", "<cmd>GpVnew<cr>", desc = "GpVnew" },
        { "<C-g>n", "<cmd>GpNextAgent<cr>", desc = "Next Agent" },
        { "<C-g>r", "<cmd>GpRewrite<cr>", desc = "Inline Rewrite" },
        { "<C-g>s", "<cmd>GpStop<cr>", desc = "GpStop" },
        { "<C-g>t", "<cmd>GpChatToggle<cr>", desc = "Toggle Chat" },
        { "<C-g>w", group = "Whisper" },
        { "<C-g>wa", "<cmd>GpWhisperAppend<cr>", desc = "Whisper Append (after)" },
        { "<C-g>wb", "<cmd>GpWhisperPrepend<cr>", desc = "Whisper Prepend (before)" },
        { "<C-g>we", "<cmd>GpWhisperEnew<cr>", desc = "Whisper Enew" },
        { "<C-g>wn", "<cmd>GpWhisperNew<cr>", desc = "Whisper New" },
        { "<C-g>wp", "<cmd>GpWhisperPopup<cr>", desc = "Whisper Popup" },
        { "<C-g>wr", "<cmd>GpWhisperRewrite<cr>", desc = "Whisper Inline Rewrite" },
        { "<C-g>wt", "<cmd>GpWhisperTabnew<cr>", desc = "Whisper Tabnew" },
        { "<C-g>wv", "<cmd>GpWhisperVnew<cr>", desc = "Whisper Vnew" },
        { "<C-g>ww", "<cmd>GpWhisper<cr>", desc = "Whisper" },
        { "<C-g>x", "<cmd>GpContext<cr>", desc = "Toggle GpContext" },
      },
    })
  end,
}

Conclusion

I hope you enjoyed this talk and learned something new about AI in Neovim. If you have any questions or comments, feel free to reach out to me on social media.

Carlos Beckers's Dev Workflow

Sat, 24 Aug 2024 10:00:00 GMT

In this interview I talk with Carlos, creator of Go Releaser, about his developer workflow including tmux, neovim, nix, and more on macOS.

Uses (hardware and software): carlosbecker.com/uses
Creator of Go Releaser: goreleaser.com
Works for Charm: charm.sh
Moonlander keyboard config

Smart tmux sessions with sesh

Fri, 10 May 2024 11:00:00 GMT

The way I use Tmux has changed a lot in the last year, so let’s talk about it.

Intro

I rewrote my tmux plugin called ‘t’ in early 2024 into a new cli called sesh, written in Go. It offers more features and performance boosts compared to the original bash version.

Here’s the video that started it all, breaking down the idea of combining zoxide and fzf for a more efficient workflow:

How to install

Instead of using tpm to install it as a tmux plugin, sesh is a binary that you install on your machine using Homebrew or Nix.

Run the following command to install it via homebrew:

brew install joshmedeski/sesh/sesh

Other installation methods are available on the sesh GitHub page.

How it works

Sesh combines zoxide and tmux sessions to create a powerful and efficient workflow. The two main commands are sesh list to list zoxide records, custom config records, and running tmux Sessions, and sesh connect to connect to a directory and create a Tmux Session.

My YouTuber friend, Dreams of Autonomy, has a great video explaining how zoxide works.

Getting Started

Using sesh connect with sesh list and tools like fzf or gum allows for quick selection and creation of Tmux Sessions based on the chosen project or directory.

sesh connect "$(sesh list | fzf)"

I prefer gum as I find it faster and prettier.

sesh connect "$(sesh list -i | gum filter --limit 1 --placeholder 'Pick a sesh' --prompt='⚡')"

Startup

Creating custom Tmux Bindings like K displays a pop-up to switch between or create new tmux Sessions on the fly using a keybinding, similar to command palettes in Discord and GitHub.

bind-key "K" display-popup -E -w 40% "sesh connect \"$(
  sesh list -i | gum filter --limit 1 --placeholder 'Pick a sesh' --prompt='⚡'
)\""

If you want a more complex setup, you can use fzf to add keybindings to filter by category or even take actions like kill tmux sessions from within the popup.

bind-key "J" run-shell "sesh connect \"$(
  sesh list -i | fzf-tmux -p 55%,60% \
    --no-sort --border-label ' sesh ' --prompt '⚡  ' \
    --header '  ^a all ^t tmux ^x zoxide ^g config ^d tmux kill ^f find' \
    --bind 'tab:down,btab:up' \
    --bind 'ctrl-a:change-prompt(⚡  )+reload(sesh list -i)' \
    --bind 'ctrl-t:change-prompt(🪟  )+reload(sesh list -it)' \
    --bind 'ctrl-g:change-prompt(⚙️  )+reload(sesh list -ic)' \
    --bind 'ctrl-x:change-prompt(📁  )+reload(sesh list -iz)' \
    --bind 'ctrl-f:change-prompt(🔎  )+reload(fd -H -d 2 -t d -E .Trash . ~)' \
    --bind 'ctrl-d:execute(tmux kill-session -t {})+change-prompt(⚡  )+reload(sesh list)'
)\""

macOS keybinding

Binding Sesh to a macOS keybinding like command+K creates a command bar to move between Sessions quickly and easily.

Naming Sessions

Sesh uses the folder name as the session name by default, but can create more contextualized session names based on the directory structure or git work trees.

For example, the ~/c/Downloads directory can be named Downloads in Tmux, while the ~/c/github.com/joshmedeski/sesh directory can be named sesh in Tmux.

In a git repository like ~/c/joshmedeski.com/src/content, sesh will automatically detect the root of the git repository and name the tmux session joshmedeski_com/src/content.

If you’re working with git worktrees, sesh will use the root of the worktree on the session name. So if I’m working with the directory ~/c/sesh/v2 where v2 is a worktree, the session name will be sesh/v2, making it easy to contextualize all sesh wokrtrees in your workflow.

Custom configs

Custom configurations can be created using a toml file in the ~/.config/sesh directory. Sessions can be defined with a location, name, startup command, and startup script to automate actions like opening a file picker or starting a website.

# open the file manager
[[session]]
name = "Downloads 📥"
path = "~/Downloads"
startup_command = "yazi"

# open a file
[[session]]
name = "tmux config"
path = "~/c/dotfiles/tmux"
startup_command = "nvim tmux.conf"

# run a script to startup a node project
[[session]]
path = "~/c/joshmedeski.com"
startup_script = "~/.config/sesh/scripts/node_dev"

The script is a executable bash file with some simple tmux commands.

#!/usr/bin/env bash
tmux split-window -v -l 10 dev
tmux select-pane -t :.+
tmux send-keys "nvim +GoToFile" Enter

You can also import other toml files if you want to break up your configs.

import = ["~/c/joshmedeski.com/.sesh.toml"]

Default Startup

Setting a default startup command like opening NeoVim with a file picker allows for quick access to recently used files whenever switching between sessions and projects for all your projects that don’t have a custom configuration.

[default_session]
startup_command = "nvim -c ':Telescope find_files'"

Raycast

The sesh companion extension for Raycast makes it easy to use sesh outside of the terminal.

Here are limitations to keep in mind:

tmux has to be running before you can use the extension
The extension caches results for a few seconds, so it may not always be up to date

Adding to Zoxide

To make Sesh more useful, it’s important to add records to Zoxide. This can be done by cding into directories or using a shortcut like zad to list and add multiple directories at once.

ls -d */ | xargs -I {} zoxide add {}

Wrapping Up

Sesh is a powerful tool that combines zoxide and tmux sessions to create a more efficient workflow. It allows for quick selection and creation of tmux sessions based on the chosen project or directory, and can be customized with custom configurations and startup scripts to automate actions.

Please give it a star and share it with your friends if you find it useful!

joshmedeski/sesh

Smart session manager for the terminal

Switching from Mackup to Stow Dotfiles Manager

Mon, 15 Apr 2024 09:00:00 GMT

For many years, I used mackup to manage my dotfiles. However, its opinionated and complicated system started feeling more burdensome than beneficial. Craving simplicity, I switched gears towards GNU Stow. This article chronicles my transition from Mackup to the minimalist environment of Stow, demonstrating how simplicity can streamline your workflow.

As someone who spends all of their time in the terminal. It is important for me to able to manage my dotfiles. Symbolic links are the easiest way to achieve this so it can commit and push changes to a single repository.

The Challenge with Mackup

Mackup is a popular dotfiles manager that allows users to synchronize application settings across multiple devices. It is a powerful tool that can back up and restore your dotfiles to cloud storage services like Dropbox and Google Drive. However, as I delved deeper into Mackup, I found its complexity and opinionated nature to be a hindrance.

At a high level, Mackup would copy the file in the application’s configuration directory to a backup directory. It would then create a symbolic link to the backup file in the application’s configuration directory. This process was repeated for each application, using a configuration file to determine which files to back up. This approach was effective but came with its own set of challenges. Especially when something went wrong, it was difficult to troubleshoot and fix.

Over the years, I saw many people complain about Mackup’s complexity which often caused confusion. I also saw community members suggest features and improvements to Mackup, which were never implemented. This led me to question the sustainability of using Mackup as my dotfiles manager. I even reached out the moderator of the Mackup repository to see if I could help maintain the project. However, I never received a response.

This left me wanting more from my dotfiles manager. There are many choices out there but I craved something simple, strait-forward, and easy to use. Which is when I discovered GNU Stow.

Introducing GNU Stow

GNU Stow is a symlink farm manager which takes dotfiles from my git repository and symlink them to the correct location. It is a simple and lightweight tool that allows me to manage my dotfiles with ease. This requires that I have my dotfiles in a specific directory structure, but this is a small price to pay for the simplicity that Stow provides. Plus after a decade of being used to dotfiles, the idea of starting from a repo and sending my dotfiles to the correct location was all I needed.

Stow works as one step for me. I can clone my dotfiles repo and run stow -t ~ and all my dotfiles will be symlinked to the correct location. This is a much simpler process than Mackup and has been a game changer for me.

Stow is also unopinionated (unlike Mackup). I have control to symlink what I want and where to place them. This has been a huge benefit for me as I can now manage my dotfiles the way I want to and no longer have to work against the tool, or add boilerplate configuration logic to extend it to my needs (like I did with Mackup).

Moving Dotfiles from Mackup to Stow

Since I had already moved all my dotfiles to a git repository, the transition from Mackup to Stow was relatively straightforward. I followed these steps to migrate my dotfiles. Which only took a few minutes.

Run mackup uninstall to remove all the symlinks created by Mackup
Remove all the config files and directories in my home diretory
Install stow (brew install stow)
Run stow -t ~ in my dotfiles directory

That’s it! Because Mackup and Stow both use symlinks and store files in the same structure, the transition was seamless. I was able to maintain my existing dotfiles structure and continue managing them with Stow. The added bonus was that I could now manage my dotfiles with greater flexibility and control.

Conclusion

I spent many weeks researching, contemplating, and asking for advice for which tool to transition to. There are many interesting and powerful tools out there for managing dotfiles. I was unhappy with Mackup’s complexity and stale development, so I decided to switch to Stow. The transition was smooth, and I am now enjoying the simplicity and flexibility that Stow provides which has made my workflow more efficient.

Stow is a great tool for managing dotfiles. It is simple, lightweight, and unopinionated. It allows me to manage my dotfiles the way I want to, without any unnecessary complexity. I am happy with my decision to switch to Stow and would recommend it to anyone looking for a simple and efficient way to manage their dotfiles.

Check out GNU Stow

Check out my dotfiles:

joshmedeski/dotfiles

Josh's dotfiles for his developer environment

Top 4 Fuzzy CLIs

Mon, 22 Jan 2024 09:00:00 GMT

Command-line interfaces (CLIs) are great for productivity, but they often Fuzzy CLIs make it easier to use the command line by providing a fuzzy search interface that allows you to find commands quickly and easily.

Thankfully, there are many to choose from, some standing out more than others. Here is my list of the top 5 fuzzy CLIs that I’ve used.

Installation

All of these CLIs can be installed with homebrew. So they all pass my first test of being easy to install.

4. zf

natecraddock/zf

a commandline fuzzy finder and zig module designed for filtering filepaths

Written in Zig, zf is fast and simple. It’s a little more minimal than the others, but it gets the job done. It is the least popular on this list, but has a focus on file paths and I discovered it while looking for a way to improve the fuzzy results for Neovim’s Telescope plugin.

natecraddock/telescope-zf-native.nvim

native telescope bindings to zf for sorting results

Overall this is bottom of the list because you can’t do much to change the look of it and the configuration options are pretty limited as a CLI. But in Telescope, it’s great.

3. gum

charmbracelet/gum

A tool for glamorous shell scripts

Gum is the most feature-filled CLI that I use, but as a fuzzy CLI it ranks 3rd on my list. It’s written in Go and is apart of the Charmbracelet suite of CLI tools. The fuzzy feature is a subcommand called “filter” and most of the configuration options are focused on the way it looks.

I think the fuzzy algorithm and the visuals make it one of my favorites, personally, but it’s lack of configuration options compared to the next two put it in 3rd place.

2. skim

lotabout/skim

Fuzzy Finder in rust!

Skim is a one I recently discovered and it is written in Rust, a fan favorite language for terminal tools. It offers many great features and is fast.

1. fzf

junegunn/fzf

A command-line fuzzy finder

fzf is the most popular (by a lot) in the fuzzy CLI space, I have been using it for many years and it’s very feature rich including keybindings to update the list and execute commands. It’s written in Go and is a crowd favorite.

Make Your Yearly Review Easier with AI

Mon, 08 Jan 2024 09:00:00 GMT

AI tools like ChatGPT can make the process of doing a yearly review much easier! I’ll go over the AI prompt and process that I used this year for my yearly review.

AI has made my life a lot easier and I’m excited to share with you how I used it to make my yearly review easier.

The Tools

I use Obsidian for all my note-taking, including journaling my yearly review, and Raycast AI for ChatGPT integration on macOS.

Prompt

The following prompt will generate questions for your yearly review:

You are a productivity coach, you will help me align
my life with what's most important to me. I am doing
a yearly review and I will be reflecting on the last
year and thinking about the year ahead. Give me a
group of questions that will help me with each area
of my life. Wait until I give you an area then give
me the questions as bullet points in markdown.

Then provide it with an area of your life, such as: “health”, “fitness”, or “hobbies” and it will generate a list of questions for you to answer.

Areas

Ali Abdaal’s video discussing his wheel of life:

Also check out Tiago Forte’s Building A Second Brain to learn more about the PARA method and how to organize your life, including creating areas of responsibility.

Bonus prompt formula

Creating a prompt forumla will help your results be more consistent and focused on your needs. Here is the formula I use to generate better results.

{role} {purpose} {context} {instructions} {conditions}

Conclusion

More fun in the terminal with Wezterm!

Thu, 14 Dec 2023 16:00:00 GMT

Wezterm is a my new favorite terminal emulator. It’s been fun to create some customizations for it using the lua programming language. In this video, I’ll show you how I swap out background images, fonts, and color schemes using lua. I’ll also show you a tip for how to get rid of the notch if you have a MacBook.

Here’s the helper function I created to get a random entry from a table:

local wezterm = require("wezterm")
local M = {}

M.get_random_entry = function(tbl)
  local keys = {}
  for key, _ in ipairs(tbl) do
    table.insert(keys, key)
  end
  local randomKey = keys[math.random(1, #keys)]
  return tbl[randomKey]
end

return M

You can view all of my Wezterm configure here: github.com/joshmedeski/dotfiles/.config/wezterm

If you want to learn more about Wezterm, check out the official docs: wezfurlong.org/wezterm

The Underrated Square Bracket (NeoVim Conf 2023)

Tue, 05 Dec 2023 00:00:00 GMT

Let’s talk about the underrated square bracket. I don’t think it’s a very popular Vim motion but I hope that after this talk you add it to your workflow. It’s a really simple Vim motion that helps me be more efficient, which is all we want with NeoVim right, I’m excited to show you how it works so let’s get into it.

Note: the following configuration snippets are all compatible with the lazy.nvim package manager.

References (`]]` & `[[`)

The simplest version of this motion is hitting the right square bracket twice (]]) which will jump you to the next reference under your cursor. Conversely, if you go to the left square brackets twice ([[) it can go backwards.

  return {
    "RRethy/vim-illuminate",
    event = "LazyFile",
    opts = {
      delay = 200,
      large_file_cutoff = 2000,
      large_file_overrides = {
        providers = { "lsp" },
      },
    },
    config = function(_, opts)
      require("illuminate").configure(opts)

      local function map(key, dir, buffer)
        vim.keymap.set("n", key, function()
          require("illuminate")["goto_" .. dir .. "_reference"](false)
        end, { desc = dir:sub(1, 1):upper() .. dir:sub(2) .. " Reference", buffer = buffer })
      end

      map("]]", "next")
      map("[[", "prev")

      -- also set it after loading ftplugins, since a lot overwrite [[ and ]]
      vim.api.nvim_create_autocmd("FileType", {
        callback = function()
          local buffer = vim.api.nvim_get_current_buf()
          map("]]", "next", buffer)
          map("[[", "prev", buffer)
        end,
      })
    end,
    keys = {
      { "]]", desc = "Next Reference" },
      { "[[", desc = "Prev Reference" },
    },
  },

Buffers (`]b` & `[b`)

You can move forward and backward through buffers using the square bracket and “b” (]b) so we can go forward and we can go back ([b).

vim.keymap.set("n", "[b", "<cmd>bprevious<cr>", {
  desc = "Prev buffer",
})

vim.keymap.set("n", "]b", "<cmd>bnext<cr>", {
  desc = "Next buffer",
})

Git Hunks (`]g` & `[g`)

One of my favorites is jumping between Git hunks hunks using square bracket and “g” (]g).

return {
  "lewis6991/gitsigns.nvim",
  event = "BufReadPre",
  opts = function()
    --- @type Gitsigns.Config
    local C = {
      on_attach = function(buffer)
        local gs = package.loaded.gitsigns
        local function map(mode, l, r, desc)
          vim.keymap.set(mode, l, r, { buffer = buffer, desc = desc })
        end
        map("n", "]g", gs.next_hunk, "Next Hunk")
        map("n", "[g", gs.prev_hunk, "Prev Hunk")
      end,
    }
    return C
  end,
}

LSP

LSP Diagnostics (`]d` & `[d`)

My most common use with using the square bracket motion is with LSPs and so in this case we can see two diagnoses showing and so I can do bracket “d” (]d) for “diagnostic”.

LSP Errors (`]e` & `[e`)

Similarly if I want to go directly to the first error I can do bracket “e” (]e) .

LSP Warnings (`]w` & `[w`)

And if I want to go to warning specifically I can do bracket “w” (]w).

Here are all the mappings I use for this:

local diagnostic_goto = function(next, severity)
  local go = next and vim.diagnostic.goto_next or vim.diagnostic.goto_prev
  severity = severity and vim.diagnostic.severity[severity] or nil
  return function()
    go({ severity = severity })
  end
end
map("n", "]d", diagnostic_goto(true), { desc = "Next Diagnostic" })
map("n", "[d", diagnostic_goto(false), { desc = "Prev Diagnostic" })
map("n", "]e", diagnostic_goto(true, "ERROR"), { desc = "Next Error" })
map("n", "[e", diagnostic_goto(false, "ERROR"), { desc = "Prev Error" })
map("n", "]w", diagnostic_goto(true, "WARN"), { desc = "Next Warning" })
map("n", "[w", diagnostic_goto(false, "WARN"), { desc = "Prev Warning" })

TODO Comments (`]t` & `[t`)

If you like to use to-do comments I have it set up so I can use square bracket “t” (]t) to switch between different to-do comments.

return {
  "folke/todo-comments.nvim",
  cmd = { "TodoTrouble", "TodoTelescope" },
  event = "LazyFile",
  config = true,
  keys = {
    { "]t", function() require("todo-comments").jump_next() end, desc = "Next todo comment" },
    { "[t", function() require("todo-comments").jump_prev() end, desc = "Previous todo comment" },
  }
}

Treesitter

Classes & Functions (`]c` & `[c`)

Another motion I use that is a bit less common than the others is using square bracket “c” (]c) to jump up to the parent are of a class.

Functions (`]f` & `[f`)

Similarly, if we want to go up in a function we can use the square bracket “f” motion (]f).

return {
  "nvim-treesitter/nvim-treesitter",
  opts = {
    textobjects = {
      move = {
        enable = true,
        goto_next_start = { ["]f"] = "@function.outer", ["]c"] = "@class.outer" },
        goto_next_end = { ["]F"] = "@function.outer", ["]C"] = "@class.outer" },
        goto_previous_start = { ["[f"] = "@function.outer", ["[c"] = "@class.outer" },
        goto_previous_end = { ["[F"] = "@function.outer", ["[C"] = "@class.outer" },
      },
    },
  }

Note on complex motions

I’d like to point out that in general this motion is a lot more simple than the ones that we might be used to where we can prepend numbers in front of our motions (ex: w2 to jump to the second word) in order to be even more accurate or to skip references. In this case if I were to do two bracket bracket (2]]) we can see that it only honors the second part of that motion and goes to the next entry which is unfortunate. But, once you get used to it, I find it very useful to be in my workflow.

Jumping out of view

So far I’ve shown some rather contrived, albeit very short, examples where everything is on the screen but the real power of this motion is that you can get to things that you want even when they’re not visible so if this error is 50 lines down I can just use my motion of square bracket “e” (]e) and I can jump all the way to anywhere in the file in which I’m looking for a particular thing albeit it warnings or motions or references or whatever it might be.

Customizing

Now let’s look at an example of how you would set this so in this case we’re just using the Vim keymap set command um and you set the mode you set the key mapping you set the command you want to fire on that key mapping and the description is really helpful for if you use tools like which key which I do.

vim.keymap.set("n", "[b", "<cmd>bprevious<cr>", {
  desc = "Prev buffer",
})

vim.keymap.set("n", "]b", "<cmd>bnext<cr>", {
  desc = "Next buffer",
})

Conclusion

And that’s my lightning talk on the underrated square bracket motion I don’t see people using this motion very much but I use it every day and I find it incredibly helpful and so I hope that it will help you as well.

A big thanks to the NeoVim conf team for putting on this conference and for inviting me to speak. Thanks so much for inviting me I really appreciate it.

Now it’s your turn go start using this underrated square bracket motion and I’ll see you guys next time.

This was a lightning talk given at NeoVim Conf, 2023. Learn more about it here: neovimconf.live

Using bun with astro

Wed, 13 Sep 2023 19:00:00 GMT

Experimenting with the new bun runtime with the astro framework.

Note: I ultimately didn’t deploy Astro with bun because of bun’s current limitations. You can watch the stream to see me work through the issues, or read the highlights below.

Highlights

Bun is fast! Install times are significantly faster
Sharp isn’t supported by bun yet, so I had back to Squoosh to get images working
Netlify can’t build, there seems to be something wrong with how dependencies are installed
Vercel can build, but the View Transitions API doesn’t work on the deployed site

Resources

Upgrading to Astro v3

Thu, 31 Aug 2023 12:00:00 GMT

Code along with me as I upgrade my website to Astro 3.0! It’s 30% faster and more powerful than ever. We’ll explore new features like view transitions, image optimization, JSX Fast Refresh, and so much more.

Here are the highlights of what we’ll cover:

Upgrade packages: We’ll upgrade all our Astro dependencies to the latest version of 3.0. We’ll also make sure the site still builds, runs locally, and deploys successfully. This update includes a 30-75% performance boost for Astro components and a 30% build time reduction.
Image Optimization: Astro now supports image optimization out of the box. We’ll update the site to use the new built-in <Image> component and explore the new image optimization features. I ended up reducing the size of some of my images by over 90%!
View Transitions: We’ll experiment with the new web platform API that unlocks native browser transition effects between pages, without any JavaScript required. The goal is to morph the post thumbnails between page routes.

Overall it was a fun stream! I had some hiccups with the new View Transitions API but once we figured it out it turned out great! You can view all of the work in the pull request.

View pull request

Dolev Hadar's Dev Workflow

Fri, 18 Aug 2023 12:30:00 GMT

Learn about Dolev’s, creator of gh-dash, tmux and neovim setup on macOS.

dlvhdr/dotfiles

Terminal Emulator

kovidgoyal/kitty

Cross-platform, fast, feature-rich, GPU based terminal

Shell

fish-shell/fish-shell

The user-friendly command line shell.

Prompt

starship/starship

The minimal, blazing-fast, and infinitely customizable prompt for any shell!

Multiplexer

tmux/tmux

tmux source code

Tmux Plugins

joshmedeski/t-smart-tmux-session-manager

t - the smart tmux session manager

joshmedeski/tmux-nerd-font-window-name

Nerd Font icons for your tmux windows

Code Editor

neovim/neovim

Vim-fork focused on extensibility and usability

Neovim Plugins

folke/lazy.nvim

A modern plugin manager for Neovim

DNLHC/glance.nvim

Peek preview window for LSP locations in Neovim

ggandor/leap.nvim

Neovim's answer to the mouse

prochri/telescope-all-recent.nvim

(F)recency sorting for all Telescope pickers.

aaronhallaert/advanced-git-search.nvim

Search your git history by commit message, content and author in Neovim

pwntester/octo.nvim

Edit and review GitHub issues and pull requests from the comfort of your favorite editor

dlvhdr/gh-dash

A beautiful CLI dashboard for GitHub

extrawurst/gitui

Blazing fast terminal-ui for git written in rust

Additional Resources

It was great being able to talk to Dolev and learn more about how he gets things done with his terminal emulator. You can check out his website to learn more about him and connect with him.

GitHub In The Terminal

Wed, 16 Aug 2023 21:00:00 GMT

Let’s integrate GitHub into the terminal using the GitHub CLI, gh-dash, and the Octo Neovim plugin. In this live stream I experiment with adding new features to my tools to improve my experience with using GitHub on the command line.

gh-dash

dlvhdr/gh-dash

A beautiful CLI dashboard for GitHub

Here are a couple of features I added to gh-dash:

keybindings:
  issues:
    - key: e
      command: >
        tmux display-popup -d {{.RepoPath}} -w 80% -h 90% -E 'nvim -c ":Octo issue edit {{.IssueNumber}}"'
    - key: i
      command: >
        tmux display-popup -d {{.RepoPath}} -w 80% -h 90% -E 'nvim -c ":Octo issue create"'
  prs:
    - key: O
      command: >
        tmux new-window -c {{.RepoPath}} 'nvim -c ":Octo pr edit {{.PrNumber}}"'

Also, in order to keep gh dash up-to-date, run the following command:

gh extension upgrade --all

Octo.nvim

pwntester/octo.nvim

Edit and review GitHub issues and pull requests from the comfort of your favorite editor

Here is how I configure Octo.nvim using the Lazy.nvim plugin manager:

return {
  "pwntester/octo.nvim",
  cmd = "Octo",
  dependencies = {
    "nvim-lua/plenary.nvim",
    "nvim-telescope/telescope.nvim",
    "nvim-tree/nvim-web-devicons",
  },
  config = function()
    require("octo").setup({ enable_builtin = true })
    vim.cmd([[hi OctoEditable guibg=none]])
  end,
  keys = {
    { "<leader>o", "<cmd>Octo<cr>", desc = "Octo" },
  },
}

I had previously created many custom leader key bindings but found I wasn’t using them. So, thanks to this issue I opened, I can simplify it down to <leader>o which opens Telescope with all the potential Octo commands.

gitlinker.nvim

ruifm/gitlinker.nvim

A lua neovim plugin to generate shareable file permalinks (with line ranges) for several git web frontend hosts. Inspired by tpope/vim-fugitive's :GBrowse

This plugin makes it easy to get a unique GitHub URL to a line of code in a repo. You can use the following lines to install it with lazy.nvim:

return {
  "ruifm/gitlinker.nvim",
  dependencies = "nvim-lua/plenary.nvim",
  opts = {},
}

Now, you can press <leader>gy and it will automatically detect the line your cursor is on and copy a unique GitHub URL to that source code to your clipboard.

gitsigns.nvim

lewis6991/gitsigns.nvim

Git integration for buffers

This is my favorite git plugin for Neovim. It has many features, primarily showing git diff status in the sign column. Here is how I configure it using lazy.nvim:

return {
  "lewis6991/gitsigns.nvim",
  event = "BufReadPre",
  opts = function()
    local icons = require("config.icons")
    --- @type Gitsigns.Config
    local C = {
      on_attach = function(buffer)
        local gs = package.loaded.gitsigns

        local function map(mode, l, r, desc)
          vim.keymap.set(mode, l, r, { buffer = buffer, desc = desc })
        end

        map("n", "]g", gs.next_hunk, "Next Hunk")
        map("n", "[g", gs.prev_hunk, "Prev Hunk")
        map({ "n", "v" }, "<leader>gg", ":Gitsigns stage_hunk<CR>", "Stage Hunk")
        map({ "n", "v" }, "<leader>gx", ":Gitsigns reset_hunk<CR>", "Reset Hunk")
        map("n", "<leader>gG", gs.stage_buffer, "Stage Buffer")
        map("n", "<leader>gu", gs.undo_stage_hunk, "Undo Stage Hunk")
        map("n", "<leader>gX", gs.reset_buffer, "Reset Buffer")
        map("n", "<leader>gp", gs.preview_hunk, "Preview Hunk")
        map("n", "<leader>gb", function()
          gs.blame_line({ full = true })
        end, "Blame Line")
        map("n", "<leader>gd", gs.diffthis, "Diff This")
        map("n", "<leader>gD", function()
          gs.diffthis("~")
        end, "Diff This ~")
        map({ "o", "x" }, "ih", ":<C-U>Gitsigns select_hunk<CR>", "GitSigns Select Hunk")
      end,
    }
    return C
  end,
}

The commands I hightlight in the live stream are ]g and [g to navigate between hunks, <leader>gg and <leader>gx to stage and reset hunks, and <leader>gG to stage the entire buffer.

lazygit

jesseduffield/lazygit

simple terminal UI for git commands

Lastly, I integrated Octo more into my favorite git CLI tool, lazygit, by overwritting the “o” command with a custom command and setting the origional command to “O”.

customCommands:
  - key: 'o'
    command: "nvim -c ':Octo pr create'"
    context: 'localBranches'
    loadingText: 'Loading Octo'
    description: 'Open pull request with Octo'
    subprocess: true
keybinding:
  branches:
    createPullRequest: 'O'

Overall this was fun exploring these tools on the live stream. Each of the tools explored have different features to offer and I can see myself replacing a lot of my time on github.com with gh-dash, octo.nvim, and lazygit.

Building MDX GitHub Embeds with Astro

Thu, 10 Aug 2023 12:00:00 GMT

Learn how to easily create MDX GitHub embeds using Astro in this step-by-step tutorial. Enhance your blog posts with dynamic GitHub content for a seamless and interactive reading experience. Here’s how to build an MDX GitHub embed with Astro!

Here’s an outline of the steps needed to build an MDX GitHub embed with Astro:

Create a <GhRepo /> Astro component
Use the component in an MDX file
Cache data to sqlite with Prisma and sqlite
Deploy to Netlify

1. Create a `<GhRepo />` Astro component

Astro components are a great way to create reusable components and share them across your application. In this case, we’ll create a <GhRepo /> component that uses Ocotokit to pull repo datat from the GitHub API and display it in a card.

---
import { GitHubIcon } from './icons/index.astro'

interface Props {
  repo: string
}
const { repo } = Astro.props

async function getRepoData(repo: string) {
  const octokit = new Octokit({ auth: process.env.GH_TOKEN })
  const repoSplit = repo.split('/')
  const { data } = await octokit.rest.repos.get({
    owner: repoSplit[0],
    repo: repoSplit[1],
  })
  return data
}

const {
  full_name: fullName,
  description,
  stargazers_count: stargazersCount,
  html_url: url,
} = await getRepo(repo)
---

<a href={url} target="_blank" class="not-prose mb-4 block no-underline">
  <section
    class="flex flex-col gap-2 rounded bg-gh-light p-2 sm:flex-row sm:gap-4 sm:p-4"
  >
    <GitHubIcon class="w-8 text-gh-dark sm:w-16" />
    <div>
      <strong class="sm:text-lg">{fullName}</strong>
      <p class="sm:text-md text-sm leading-none text-gh-dark">{description}</p>
      <div class="text-gh-dark">🔭 {stargazersCount.toLocaleString()}</div>
    </div>
  </section>
</a>

It will look something like this:

octokit/octokit.js

The all-batteries-included GitHub SDK for Browsers, Node.js, and Deno.

Note, I’m using TailwindCSS, and emoji, and an SVG icon component that I created. You can use whatever you want to style your component.

2. Use the component in an MDX file

To use the <GhRepo /> component in a MDX file, we will define it as a reusable component in the blog post layout’s Astro file.

---
import { getCollection } from 'astro:content'
import type { CollectionEntry } from 'astro:content'
import { components } from '../../components/MdxComponents'
import GhRepo from './GhRepo.astro'

export async function getStaticPaths() {
  const posts = await getCollection('posts')
  return posts.map((post) => {
    return {
      params: { slug: post.slug },
      props: { post },
    }
  })
}

interface Props {
  post: CollectionEntry<'posts'>
}

const { post } = Astro.props
const { Content } = await post.render()
---

<Content components={{ GhRepo }} />

Thanks to Stefan Imhoff (@kogakure) for the tip on twitter!

I highly recommend you check out Astro’s content collections guide to learn more about how to build type-safe markdown content.

Now, you can call the <GhRepo /> component in your markdown file, making sure to include the repo prop we defined.

---
title: Building MDX GitHub Embeds with Astro
---

It will look something like this:

<GhRepo repo="octokit/octokit.js" />

3. Cache data to sqlite with Prisma and sqlite

Next, we’ll want to create a Prisma model and service to cache the data from the GitHub API to sqlite. This will allow us to make fewer API calls and speed up our application.

model GhRepo {
  fullName        String   @unique
  description     String?
  stargazersCount Int      @default(0)
  url             String   @unique
  updatedAt       DateTime @updatedAt @map("updated_at")
}

You can learn more about how to use Prisma with sqlite in this guide.

Then, we’ll update the GhRepo component logic to handle the API calls and caching.

async function addRepoToCache(repo: string) {
  const data = await getRepoData(repo)
  const dataToSave = {
    fullName: data.full_name,
    ...(data.description ? { description: data.description } : {}),
    stargazersCount: data.stargazers_count,
    url: data.html_url,
  }
  return await prisma.ghRepo.upsert({
    where: { fullName: data.full_name },
    update: dataToSave,
    create: dataToSave,
  })
}

async function getRepo(repo: string) {
  const cachedRepo = await prisma.ghRepo.findFirst({
    where: { fullName: repo },
  })

  if (
    !cachedRepo ||
    cachedRepo.updatedAt <
      new Date(new Date().getTime() - 1000 * 60 * 60 * 24 * 7)
  ) {
    return await addRepoToCache(repo)
  } else {
    return cachedRepo
  }
}

const { fullName, description, stargazersCount, url } = await getRepo(repo)

A couple of things to notice here:

Using an upsert allows us to update the repo if it already exists, or create it if it doesn’t.
A simple conditional check allows us to only call the GitHub API if the repo doesn’t exist in the database, or if it hasn’t been updated in the last week.

4. Deploy to Netlify

Finally, we can deploy the application to Netlify. It’s important to configure your Netlify configuration to run prisma’s migrate command before building the Astro app.

[build.environment]
  NPM_FLAGS = "--version" # prevent Netlify npm install

[build]
  command = 'npx pnpm i --store=node_modules/.pnpm-store && prisma migrate dev && npm run build'
  publish = 'dist'

That’s how you can build an MDX GitHub Embed with Astro, Prisma, and sqlite! We created a <GhRepo /> Astro component and styled it with TailwindCSS, pulled the data from the GitHu API using Octokit, cached it to local sqlite with Prisma, and deployed it to Netlify.

All the code can be found on the pull request from the live stream.

Thanks for reading! There are more Astro posts on the way, so make sure to subscribe to the newsletter to get notified when they’re published.

Create a Neovim IDE with LazyVim

Mon, 26 Jun 2023 12:00:00 GMT

LazyVim is a Neovim setup powered by 💤 lazy.nvim to make it easy to customize and extend your config. It turns Neovim into a IDE with very little effort and offers a simple and flexible structure to modify and extend it to your liking.

Install

First, you need to install neovim.

brew install neovim

I recommend going to the LazyVim installation page to get the complete and up-to-date instructions, but here’s a quick overview of how to set it up. You have to clone the starter repo, remove the .git folder, then run neovim with the nvim command.

git clone https://github.com/LazyVim/starter ~/.config/nvim # clone
rm -rf ~/.config/nvim/.git # remove .git folder
nvim # start neovim

LazyVim will automatically begin to install all it’s plugins and boot up.

Configure

LazyVim is configured with the following structure.

~/.config/nvim/lua/config/lazy.lua is the entry file to setup LazyVim and default options.
~/.config/nvim/lua/config/* holds other files that help setup basic configurations for Neovim.
~/.config/nvim/lua/plugins/* holds files that can automatically be read by LazyVim to manage plugins.

Catppuccin Theme

The default theme that ships with LazyVim doesn’t work well with Alacritty’s semi-transparent styling that we set up previously. I recommend the popular scheme catppuccin which offers great transparency support. You’ll also learn some basics for overwriting the LazyVim configuration and adding new plugins.

First, you have to install the catppuccin plugin by adding the following content to a new catppuccin.lua file in the plugins folder.

return {
  "catppuccin/nvim",
  name = "catppuccin",
  priority = 1000,
  ---@class CatppuccinOptions
  opts = {
    transparent_background = true,
  },
}

Then, you need to overwrite the default colorscheme defined by LazyVim by adding the following plugin file.

return {
  "LazyVim/LazyVim",
  opts = {
    colorscheme = "catppuccin",
  },
}

Restart Neovim and you should now have the catppuccin theme enabled with transparency support. You can learn more about how to configure catppuccin, including adding additional integration support, on it’s GitHub page.

Deep Dive

There is so much to cover with LazyVim, if you want to get a solid overview of all the features it offers, I recommend my friend Elijah Manor’s video.

Conclusion

LazyVim allows you to quickly setup an IDE for Neovim. It’s a great starting point for beginners and offers a simple and flexible structure to modify and extend it to your liking. We covered how to install it and overwrite the theme with Catppuccin. If you want to learn more about LazyVim, I recommend checking the following resources.

Manage Files with lf

Mon, 26 Jun 2023 12:00:00 GMT

lf is a terminal file manager. Having to constantly change directories with the cd command and preview files with cat can be slow and repetitive. lf allows you to quickly navigate your filesystem and preview files with a single vim-like commands.

Install

Install it homebrew with the following command.

brew install lf

Using

Using lf is as simple as running the lf command which will pull up the file manager. You can use hjkl as arrow keys to navigate the files. You can also press o to open up a file in your editor.

Configuration

lf is configured with a file located at ~/.config/lf. Here are some simple default options that I like to set.

set hidden
set icons
set number
set relativenumber
set shell fish
set promptfmt "\033[34;1m%d\033[0m\033[1m%f\033[0m"

You can add icon support by install my fish plugin:

fisher install joshmedeski/fish-lf-icons

Here’s a preview of what it looks like:

I also like to have access to lf while inside neovim, so you can add the following plugin to your LazyVim setup.

return {
  "lmburns/lf.nvim",
  cmd = "Lf",
  dependencies = { "nvim-lua/plenary.nvim", "akinsho/toggleterm.nvim" },
  opts = {
    winblend = 0,
    highlights = { NormalFloat = { guibg = "NONE" } },
    border = "single",
    escape_quit = true,
  },
  keys = {
    { "<leader>ff", "<cmd>Lf<cr>", desc = "NeoTree" },
  },
}

You’ll have to restart LazyVim, but after that you can press <space>+f+f to open lf as a floating window in the directory of the file you have open.

Conclusion

I prefer lf over sidebar style file mangers and it is infinitely customizable for your needs. We discussed install it with homebrew, configuring it to show icons, and how to use it in Neovim. Check out the lf wiki to learn how to customize it more.

Manage macOS packages with Homebrew

Mon, 26 Jun 2023 12:00:00 GMT

Homebrew is a package manager for macOS that allows users to easily install and manage software packages and libraries. It uses a command-line interface and a simple formula system to download and install packages from pre-configured sources, making it easy to keep software up to date and manage dependencies. To install Homebrew, open Terminal and run the following command:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

This will download and run the Homebrew installation script. Once installed, you can use Homebrew to install packages by running commands like brew install <package>. For example, to install the wget package, you would run:

brew install wget

If you’re unsure of the name of the package, or if it is available from homebrew, you can search for it using brew search <package>, including applications like Google Chrome.

brew search chrome
# returns the following results
==> Formulae
chrome-cli   chrome-export    chroma     rome  chrony
==> Casks
chrome-devtools    chromedriver      epichrome   mkchromecast
chrome-remote-desktop-host      chromium     google-chrome

google-chrome is listed under the Casks section, which means it is a graphical application. To install it, you run the install command with the cask flag:

brew install --cask google-chrome

Adding a custom tap

A Homebrew tap is a repository of additional formulae that are not included in the main Homebrew repository. Adding a custom Homebrew tap allows you to install software that is not available in the main repository. Here’s how to add a custom Homebrew tap:

brew install arl/arl/gitmux # owner/tap/formulae

You can also create your own tap to add homebrew support to your favorite packages and applications.

Keeping Homebrew up-to-date

To keep your packages and libraries up-to-date, Homebrew offers multiple commands. I recommend running the following commands in this order to ensure you have the latest versions of your packages and libraries.

brew update updates the local Homebrew repository with the latest version of package information from the remote repository. This ensures that you have the latest versions and dependencies of packages available to install or upgrade on your system.
brew outdated lists all installed packages that have a newer version available in the remote repository. This command helps you identify which packages are outdated and need to be updated. This is optional but provides a preview of how many packages are going to update when running the next command.
brew upgrade upgrades all outdated packages installed on your system to their latest versions available in the remote repository. This command updates the packages to their latest versions, including all their dependencies, and ensures that your system has the most up-to-date software.
brew cleanup --prune=all removes old versions of installed packages and their associated files, freeing up disk space. The --prune=all option removes all packages and their associated files, including those that are currently installed and those that are no longer needed. This command is useful when you want to reclaim disk space on your system by removing old and unused packages. However, it is recommended to use this command with caution, as it can potentially remove files that are still needed by other packages or applications.
brew doctor diagnoses potential issues with your Homebrew installation. This command checks your Homebrew installation for common issues, such as outdated packages, broken symlinks, and other configuration problems. It also provides suggestions on how to fix any issues that it finds.

Update script

I have wrapped everything you need to keep homebrew up-to-date. I will typically run this script a few times per week. Here’s how to create it.

The only dependency is a CLI tool called gum, which is a tool for glamorous shell scripts. Install it running the following command.

brew install gum

Then, create a file name b in the ~/.config/bin directory. I find this to be a useful place to create custom scripts to automate repetitive tasks.

mkdir -p ~/.config/bin && touch ~/.config/bin/b

Then, add the following content to the file.

#!/usr/bin/env bash

gum style \
  --foreground 12 --border-foreground 12 --border double \
  --align center --width 50 --margin "1 0" --padding "1 2" \
  '██████╗ ██████╗ ███████╗██╗    ██╗
██╔══██╗██╔══██╗██╔════╝██║    ██║
██████╔╝██████╔╝█████╗  ██║ █╗ ██║
██╔══██╗██╔══██╗██╔══╝  ██║███╗██║
██████╔╝██║  ██║███████╗╚███╔███╔╝
╚═════╝ ╚═╝  ╚═╝╚══════╝ ╚══╝╚══╝'

gum spin --show-output --spinner minidot --title "Updating brew..." -- brew update
printf "\n"

OUTDATED=$(gum spin --show-output --spinner minidot --title "Checking for outdated brew packages" -- brew outdated)

if [[ -n "$OUTDATED" ]]; then
  echo "$OUTDATED"
  gum confirm --selected.background=2 --selected.foreground=0 "Upgrade the outdated formulae above?" && brew upgrade
  printf "\n"
  brew cleanup --prune=all
  printf "\n"
else
  echo "All brew packages are up to date."
  printf "\n"
fi

gum spin --show-output --spinner minidot --title "Checking for brew issues..." -- brew doctor

You need to make the b script executable, add the ~/.config/bin directory to your path, on the default macOS shell, then source the zshrc for the PATH to reflect the new directory.

chmod +x ~/.config/bin/b
echo 'export PATH="~/.config/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

Finally, you can run the b command in your terminal to ensure you have the latest versions of my favorite packages and applications which includes bug fixes, security updates, and new features. But be careful, if there are breaking changes to a package, you may need to update your configuration to support the new version. You can visit the package’s release notes to see what has changed.

Summary

In summary, Homebrew is a package manager for macOS that simplifies the installation and management of software packages and libraries. It uses a command-line interface and a simple formula system to download and install packages from pre-configured sources using brew install, making it easy to keep software up-to-date and manage dependencies. To add a custom tap, you can use the brew tap command to add a repository of additional formulae that are not included in the main Homebrew repository. To keep Homebrew up-to-date, you can use brew update, brew outdated, brew upgrade, brew cleanup, and brew doctor commands. I also showed you a simple b script that automates these commands for an easy way to stay up-to-date.

Manage Terminal Sessions with tmux

Mon, 26 Jun 2023 12:00:00 GMT

tmux is a terminal multiplexer that allows you to create and manage multiple terminal sessions within a single window. It enables you to run multiple programs or shell sessions simultaneously, switch between them easily, and detach and reattach sessions, even if you disconnect from the terminal.

Install

To install tmux, run the following brew command.

brew install tmux

Creating sessions

tmux works by creating sessions, you can create your first session by running the following command.

tmux new -s "hello-world"

You’ll notice a green bar at the bottom of your terminal with the words hello-world to the far right, this is the tmux status bar!

To detach from tmux, run the detach command.

tmux detach-client

You’ll notice the green bar at the bottom disappears, but tmux is still running in the background! To reattach, you can run the attach command.

tmux attach

And just like that, you will end up back where you were before. Detaching from tmux sessions becomes very powerful as you create multiple sessions at the same time. Unlike graphical applications, like VSCode, tmux runs like a server and allows you to switch between different sessions quickly and easily with very little overhead on your computer. We’ll get more into that later.

Window commands

tmux commands are driven by the prefix key binding which is ctrl+b. Press ctrl+b (aka <prefix>) and then c to “create” a tmux window. Think of these as macOS tabs that are common in browsers and file managers.

Windows can then be split into panes with <prefix>% and killed with <prefix>x. Note, when there are multiple panes the kill command will close the active pane, if there is only one pane the kill command will close the window entirely and switch to the previous window in the session, if there are no windows left it will kill the entire session.

The prefix key is my least favorite feature of tmux. Thankfully, Alacritty allows us to create custom keybindings to recreate common macOS-style shortcuts to make tmux much easier to use. Add the following to your alacritty.yml.

key_bindings:
  - { key: E, mods: Command, chars: "\x02\"" } # split tmux window vertically
  - { key: E, mods: Command|Shift, chars: "\x02%" } # split tmux window horizontally
  - { key: T, mods: Command, chars: "\x02c" } # create a new tmux window
  - { key: W, mods: Command, chars: "\x02x" } # kill the current pane
  - { key: Tab, mods: Control, chars: "\x02n" } # switch to next tmux window
  - { key: LBracket, mods: Command|Shift, chars: "\x02p" } # switch to next tmux window
  - { key: RBracket, mods: Command|Shift, chars: "\x02n" } # switch to previous tmux window

Give these a try! These familiar shortcuts, like cmd+t will create a new tmux window and ctrl+w will close it. I have a whole video explaining all my macOS Keyboard Shortcuts for tmux if you want to learn more about how this works.

Configuration

I think tmux isn’t very pretty by default, and there are multiple options I prefer to change. All of tmux’s configuration is stored in a ~/.config/tmux/tmux.conf file. Create it and add the following options.

set -g base-index 1          # start indexing windows at 1 instead of 0
set -g detach-on-destroy off # don't exit from tmux when closing a session
set -g escape-time 0         # zero-out escape time delay
set -g history-limit 1000000 # increase history size (from 2,000)
set -g mouse on              # enable mouse support
set -g renumber-windows on   # renumber all windows when any window is closed
set -g set-clipboard on      # use system clipboard
set -g status-interval 3     # update the status bar every 3 seconds
bind-key x kill-pane         # skip "kill-pane 1? (y/n)" prompt

To style the tmux status bar, I prefer a transparent, top-aligned bar, with minimal items display.

set -g status-left "#[fg=blue,bold]#S" # session name
set -g status-left-length 200          # increase length (from 10)
set -g status-position top             # macOS / darwin style
set -g status-right ''                 # blank
set -g status-style 'bg=default'       # transparent

The session name is style using #[fg=blue,bold] to make it blue and bolded to match our starship configuration and create a more consistent look.

Plugins

tmux plugins can be managed by tpm, the tmux plugin manager. To install it you first have to clone tpm to your machine.

git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

Add the following to your tmux config file.

# List of plugins
set -g @plugin 'tmux-plugins/tpm'
set -g @plugin 'joshmedeski/tmux-fzf-url'

# Initialize TMUX plugin manager (keep this line at the very bottom of tmux.conf)
run '~/.tmux/plugins/tpm/tpm'

Save the file and run <prefix>I to install the tmux plugins.

Open URLs

Notice in the snippet above a joshmedeski/tmux-fzf-url plugin was added. This plugin allows you to open URLS visible in your tmux buffer. Once installed, you will need fzf installed to use it.

brew install fzf

<prefix>u will open a fzf window that lists all available URLs that can be opened. Including GitHub style strings (“username/repo”)! But as mentioned earlier, you can add an Alacritty keybinding to map this command to cmd+o.

key_bindings:
  # ... existing keybindings
  - { key: O, mods: Command, chars: "\x02u" } # open URLs 'joshmedeski/tmux-fzf-url'

Conclusion

tmux is extremely powerful. We covered the basic commands for creating sessions, configuring options, setting up macOS shortcuts with Alacritty, and adding your first plugin. There is much more to cover so I recommend checking out my other content on tmux, like Smart tmux sessions with zoxide and fzf . You can also run man tmux in the terminal to open the tmux manual and dive deep into everything tmux has to offer.

Quick Git Management with Lazygit

Mon, 26 Jun 2023 12:00:00 GMT

Git is a central part of the development workflow. It’s important to have a good understanding of how it works and how to use it. lazygit is a terminal UI for git that makes it easy to run common git commands efficiently and with ease.

jesseduffield/lazygit

simple terminal UI for git commands

Install

To install lazygit, you guessed it, run the following homebrew command.

brew install lazygit

It can be opened by moving to a in your teriminal to a git repository and run the lazygit command. It will open a terminal UI that offers a lot of useful git commands. You can view the available commands by pressing ?.

Custom shortcut

As mentioned in the tmux intro, we can setup lazygit to a custom macOS style shortcut cmd+g. This can be done by adding the following to your ~/.tmux.conf file.

bind g new-window -n 'lazygit' lazygit

This will bind lazygit to <prefix>g in tmux. To map that to cmd+g add the following to your alacritty config file in the key_bindings section.

key_bindings:
  # ... existing keybindings
  - { key: G, mods: Command, chars: "\x02g" } # open git manager 'jesseduffield/lazygit'

Now, you can press cmd+g to open lazygit from anywhere in your terminal. You can press q while in lazygit to close it and return to wherever you where previously.

Configure

For macOS, the configuration is located in the user application support file. Here are a few basic configuration options.

gui:
  showIcons: true
  theme:
    activeBorderColor:
      - magenta
      - bold
    inactiveBorderColor:
      - black
  showFileTree: true # for rendering changes files in a tree format
os:
  editCommand: 'nvim'
  editCommandTemplate: '{{editor}} {{filename}}'
keybinding:
  universal:
    quit: 'q'

How to use

Using lazygit is pretty straight forward. Here are a few common commands that I use often.

space toggles the selected file to the staging area
c opens the commit window, which lets you write a commit message and commit the staged changes
P pushes the current branch to the remote

There are many more commands including branch management, interacting with history, and more.

Conclusion

lazygit is the quickest and easier way to manage git repositories. It’s a great tool to have in your toolbelt and I highly recommend it. Binding to cmd+g makes it very quick to open and close. I recommend looking through the lazygit wiki to learn more about creating custom commands and more.

Customized Shell Prompt with Starship

Mon, 26 Jun 2023 12:00:00 GMT

Starship is a minimal, blazing-fast, and infinitely customizable prompt for any shell. I’ve been interviewing developers recently and the majority of them are using Starship! It’s easy to setup and configure. Here’s how to get started.

Install

Install starship by running the following brew command.

brew install starship

Now that starship is installed, you have to source it in your config.fish by adding the following line.

starship init fish | source

Configuration

To configure starship, create a ~/.config/starship.toml and add the following content.

First, swap out some of the characters with custom Nerd Font options. You can find more on Nerd Font’s website.

[character]
success_symbol = "[\uf054](white)" # 
vicmd_symbol = "[\ue62b](white)" # 
error_symbol = "[\uf467](red)" # 

Next, I prefer changing the directory name to blue, since we’ll be updating tmux in a future post to the same color as well, creating a consistent style.

[directory]
style = "blue bold"

Finally, I prefer a more minimal approach to my prompt, so I prefer disabling many of the built in modules.

[package]
disabled = true

[username]
disabled = true

[hostname]
disabled = true

[aws]
disabled = true

[docker_context]
disabled = true

[git_branch]
disabled = true

[git_commit]
disabled = true

[git_state]
disabled = true

[git_metrics]
disabled = true

[git_status]
disabled = true

Check out all the configuration options to figure out which modules you can configure or customize to your liking.

Summary

That’s it! Starship works great out-of-the-box and has a low learning-curve. It is smart and will provide contextual information related to where you are in the terminal. With a few customizations it has a minimal and consistent look making it a great addition to my dev workflow.

Set up fish, the user-friendly interactive shell

Mon, 26 Jun 2023 12:00:00 GMT

Fish (Friendly Interactive SHell) is a Unix shell designed to be user-friendly and interactive. It features syntax highlighting, autosuggestions, and a built-in help system, among other features. Fish aims to be more intuitive and easier to use than traditional Unix shells like Bash, while still providing powerful scripting capabilities. Modern macOS computers ship with zsh as the default shell, you can check out Why I Switched from zsh to fish but the main reasons are the speed, simplicity, autosuggestions and vim mode that the fish shell offers.

Installing fish

Fish does not come pre-installed on macOS, you have to install it with Homebrew by running the following command in the terminal.

brew install fish

If you’re not familiar with Homebrew, check out Managing macOS packages with Homebrew.

Making fish your default shell

Now that the fish shell is installed, you have to manually change the default shell by completing the following steps.

First, you will need to get the path to the fish shell executable. If you’re unfamiliar with how executables in the terminal work, I recommend checking out What is the terminal?. Run the following which command.

which fish

The command will output something similar to /opt/homebrew/bin/fish. Copy the value from your terminal and add it to the /etc/shells file. You’ll want to edit the file using the sudo command, since this is an system-level file that lists valid login shells for user accounts. Here is how to update it using vi.

sudo vi /etc/shells

Enter your user password to open the file then add the fish shell’s path as an new line in the file and save it.

# List of acceptable shells for chpass(1).
# Ftpd will not allow users to connect who are not using
# one of these shells.

/opt/homebrew/bin/fish # use output from `which fish`
/bin/bash
/bin/csh
/bin/dash
/bin/ksh
/bin/sh
/bin/tcsh
/bin/zsh

If you’re unfamiliar with vi, I recommend running vimtutor in your terminal which will guide you through the basics of how to edit text from inside the terminal.

Now that you’ve added fish as a valid login shell for macOS, you can run the chsh (change shell) command to change the default login shell.

Copy the command below and run all three commands at once to quickly change your default shell to fish.

cd ~
basename $(pwd) | pbcopy
chsh -s /opt/homebrew/bin/fish $(pbpaste)

You may be prompted, again, to enter your user password and when the command is completed your login shell is now switched to fish. In order for your changes to take effect, you’ll need to log out and log back in to your user account. I recommend you restart your computer for good measure. When you log back in fish will be your default shell, congrats!

Configuring fish

Fish configuration is written in its own scripting language. The entry point for configuring the fish shell is the config.fish file which can be created with the following command.

mkdir -p ~/.config/fish && touch ~/.config/fish/config.fish

This command first creates the ~/.config/fish directory with the -p option, which creates any parent directories that do not exist. Then it creates the config.fish file inside the ~/.config/fish directory using the touch command. Note: all of fish’s configuration files are stored in ~/.config/fish more of which will explore later.

Configure homebrew

I highly recommend you Manage macOS packages with Homebrew. Add the following eval code to your config file to configure homebrew with the fish shell.

eval (/opt/homebrew/bin/brew shellenv)

Note: Evaluating a command in the shell is typically done with $(cmd) but fish uses (/cmd) instead, dropping in the $. Some developers I’ve talked have chosen not to use fish because of the subtle syntax differences from more traditional shells, but I think it’s worth it.

Add directories to `PATH`

In fish, the fish_add_path function is used to add directories to the PATH environment variable. Adding directories to your system’s PATH environment variable allows you to run programs located in those directories from anywhere on your system without specifying the full path. By doing so, you extend the list of directories that the shell searches for executables, making it more convenient to run programs and execute commands.

To add support for Homebrew executables to the fish shell, add the following lines to your ~/.config.fish file.

fish_add_path ~/.config/bin

I recommend creating a ~/.config/bin directory to store any custom scripts you make come up to improve your workflow or automate tasks.

Setting environment variables

In the Fish shell, the set command is used to create and modify shell variables. Shell variables are used to store values that can be referenced and reused throughout a shell session or script. Here are some common variables that are helpful.

set -U fish_greeting # disable fish greeting
set -U fish_key_bindings fish_vi_key_bindings

The -U flag is used with the set command to create or modify a universal variable. Universal variables are similar to regular variables, but they have a global scope and can be accessed from any shell session or script.

The fish_greeting variable is used to customize the greeting message that is displayed when a new shell session is started. By default, the greeting message includes the Fish version number and a welcome message. Since I am constantly spinning up new shells in my development workflow, I prefer to disable the fish greeting by setting it with not value.

The fish_vi_key_bindings variable allows you to hit escape while writing a command in fish to switch to a vi-mode to easily manipulate your command before running it. Just like vi, you can hit i to get back to insert mode. There are many other variables you can set to customize your shell, check out the fish documentation for more information. The next most common variable to change is the default editor for your shell. This is set with the EDITOR variable.

set -Ux EDITOR nvim

Note the -x flag is used with the set command to export a variable as an environment variable. When a variable is exported, it becomes available to child processes and can be accessed by programs and utilities that use environment variables. This is helpful as you extend your development environment with other tools that can generate sub processes

Abbreviations

One of my favorite features of fish is the ability to create abbreviations. This works similar to a shell aliasm but the main difference is the abbreviation will expand when ran.

You can create abbreviations with the abbr command in your config.fish file. Let’s add a few helpful ones for homebrew.

abbr bi "brew install"
abbr bic "brew install --cask"
abbr bin "brew info"
abbr binc "brew info --cask"
abbr bs "brew search"

You’ll have to source your config.fish file for the change to be reflected in your shell.

source ~/.config/fish/config.fish

Now, you type bs<space> and you’ll see the prompt quickly expand to brew search to allow you to create commands quickly using a simple mnemonic-style abbreviations. Abbreviations speed up my dev workflow significantly and are one of my favorite features of the fish shell.

Plugins

There is a large community of plugins for the fish shell. I recommend using fisher to manage them.

curl -sL https://raw.githubusercontent.com/jorgebucaran/fisher/main/functions/fisher.fish | source && fisher install jorgebucaran/fisher

A great starter plugin for fish is sponge, which cleans your fish history from typos automatically. It can be installed with the fisher command.

fisher install meaningful-ooo/sponge

You’ll notice two things.

A ~/.config/fish/fish_plugins file was created and added sponge as a plugin. This is how fisher manages plugins.
A ~/.config/fish/functions directory was created and multiple _sponge_*.fish files were added to it. This is the plugin code which fish will automatically read to extend the shell. This folder will contain more files as you add more plugins, you can even create your own!

Summary

The fish shell is a simple, fast, and intuitive shell alternative for macOS. In this post we installed fish, set it as your default user shell, configured homebrew, added a directory to your path, customized some of fish’s options, create abbreviations, and installed your first plugin.

Set up Alacritty for a fast, minimal, terminal emulator

Mon, 26 Jun 2023 12:00:00 GMT

Choosing a good terminal emulator is important because it serves as the foundation for a productive and efficient workflow in a command-line environment. A good terminal emulator should provide a fast and responsive interface, support for various customization options, and compatibility with a wide range of programs and tools. It should also have features such as keyboard shortcuts to help users streamline their tasks and navigate the command-line interface with ease. Overall, a good terminal emulator can greatly enhance the user’s experience and make working in a command-line environment more efficient and enjoyable.

I have experimented with many terminal emulators over the years, and have ultimately decided Alacritty to be the best choice for me. It is a GPU-accelerated terminal emulator which means it is incredibly fast and efficient. It also allows you to customize fonts and spacing, as well as a semi-transparent and borderless visual which providers a minimalist look which is the biggest selling point for me.

How to install

The easiest way to add the Alacritty terminal emulator is to your computer is to install it with Homebrew by running the following command.

brew install --cask alacritty

If you’re not familiar with Homebrew check out manage macOS packages with Homebrew.

How to configure

The Alacritty terminal emulator can be configured by a hidden TOML file in your home directory. Create a ~/.config/alacritty/alacritty.toml file using the following command.

mkdir -p ~/.config/alacritty && touch ~/.config/alacritty/alacritty.toml

This command first creates the ~/.config/alacritty directory with the -p option, which creates any parent directories that do not exist. Then it creates the alacritty.conf file inside the ~/.config/alacritty directory using the touch command.

Alacritty can automatically reload the configuration file when the file is changed by setting the live_config_reload.

live_config_reload = true

The TERM shell environmental variable specifies the type of terminal emulator that is being used to interact with the shell. It tells Alacritty what features and capabilities are available. I recommend using xterm-256color. xterm supports a wide range of terminal features, including color, mouse support, and support for multiple fonts and character sets. It also supports many of the standard terminal control sequences used by Unix-like systems. 256color supports 256 colors by using an extended color palette, which allows for a greater range of colors to be displayed than the standard 16 colors supported by many terminals. This is achieved by using escape sequences to set the foreground and background colors of text.

The TERM variable is put under the env key which sets environment variables that are passed to the shell when Alacritty is launched.

[env]
TERM = "xterm-256color"

By default, Alacritty looks the same as any other terminal emulators for macOS. But there are a handful of options that give it a semi-transparent minimalist look that I find aesthetically pleasing and unique.

[window]
decorations = "buttonless"
dynamic_padding = false
opacity = 0.9

[window.padding]
x = 25
y = 20

The buttonless decorations key removes the macOS title bar and border, giving it a minimal and distraction-free look. The opacity key takes a value between 0-1 and makes the window semi-transparent. I’ve found that this value will vary based on your wallpaper. The dynamic_padding and padding keys offer hard-coded spacing between the end of the window and the content. I use predictable spacing with the values above.

Using a custom font

One of the most important customization features for any terminal emulator is picking and setting up a custom font! I’m a big fan of Nerd Fonts and I use lots of icons throughout my development environment. There are dozens of Nerd Fonts to choose from but as a macOS user I’ve prefer Apple’s San Francisco font which is a neutral, flexible, sans-serif typeface used as the system font for all Apple devices. Thankfully, Aditya has patched the SF Mono font with Nerd Font. You can download it via homebrew.

brew install epk/epk/font-sf-mono-nerd-font

You can download the “JetBrainsMono Nerd Font” font from the Nerd Fonts website.

Once the font is downloaded and installed, add the following to your config file:

[font]
size = 20.0

[font.bold]
family = "JetBrainsMono Nerd Font"
style = "Heavy"

[font.bold_italic]
family = "JetBrainsMono Nerd Font"
style = "Heavy Italic"

[font.italic]
family = "JetBrainsMono Nerd Font"
style = "Medium Italic"

[font.normal]
family = "JetBrainsMono Nerd Font"
style = "Medium"

I prefer the font styles of Medium and Heavy to add more weight to the font, I find this helps with the make it more legible with the semi-transparent window. As well as a font size of 20. These values can be adjusted that best fit your monitor and workflow.

Colorizing

Another important area to customize your development environment is choosing a color palette. A popular color pallet is Catppuccin, which is “a community-driven pastel theme that aims to be the middle ground between low and high contrast themes”.

To get the Catppuccin themes, you can clone the TOML files to your Alacritty config directory.

git clone https://github.com/catppuccin/alacritty.git ~/.config/alacritty/catppuccin

Next, Alacritty’s TOML configuration supports the ability to import other TOML files to extend customization. You can add entries to a import key:

import = ["~/.config/alacritty/catppuccin/catppuccin-mocha.toml"]

If you want to explore more color schemes, check out the Alacritty Theme repository.

Summary

Choosing a good terminal emulator is important for productivity in a command-line environment. A good terminal emulator should be fast, customizable, and compatible with a variety of programs. Alacritty is a GPU-accelerated terminal emulator that allows for customization of fonts, spacing, and visual appearance. We have installed Alacritty, customized it’s appearance with a yaml file including the terminal environment, window style, fonts, and colors.

This is just the starting point for customizing Alacrity. If you want to explore all of the features Alacritty has to offer, check out the GitHub repository for more info. You can also view my full Alacritty configuration here.

Mark Huggins' Dev Workflow

Sat, 20 May 2023 16:00:00 GMT

Mark and I talk about our Moonlander keyboard layouts and developer workflows using tmux and neovim including plugins and shortcuts we used for coding and navigating our environments. We mention various tools and plugins that we had use to customize our workflows, such as LazyVim, gitmux, and fzf. We also discuss how we use copilot in Neovim, and why we prefer minimal setups. Our conversation emphasize the importance of continually experimenting with and adapting our workflows to find what works best for us.

Mark’s Stuff

mhuggins7278/dotfiles

my .files - powered by Ansible

Josh’s Stuff

joshmedeski/dotfiles

Josh's dotfiles for his developer environment

neovim

nvim-lua/kickstart.nvim

A launch point for your personal nvim configuration

ThePrimeagen/harpoon

Getting you where you want with the fewest keystrokes.

zbirenbaum/copilot-cmp

Lua plugin to turn github copilot into a cmp source

tmux

Terminal

Customize Yabai with Lua

Sat, 06 May 2023 22:00:00 GMT

If you’re a macOS user who enjoys using the yabai window manager, you may find yourself wanting to customize your keyboard bindings to better suit your workflow. Luckily, with the help of Hammerspoon and the Lua programming language, you can easily create custom keyboard shortcuts to control yabai.

What is yabai?

yabai is a window management utility for macOS that allows you to organize your windows in a customizable and efficient way. It provides a range of features, including:

Expanding windows to fill all the available space on the screen, automatically
Splitting windows into multiple panes, automatically
Stacking windows on top of each other
Moving windows between different desktops
Resizing and positioning windows with precision

I have a video on

yabai is controlled through a command-line interface and can be customized using a configuration file, there is a common solution for yabai users called skhd. I used it for years but recently discovered a new tool that allows me to write the configuration in a proper programming language and offer some improvements and additional features called Hammerspoon.

What is Hammerspoon?

Hammerspoon is a powerful automation tool for macOS that allows you to write Lua scripts to control various aspects of your system. With Hammerspoon, you can create custom keyboard shortcuts, automate repetitive tasks, and even control other applications. I will show you how to use Lua to write simple reusable functions, as well as leverage loops to make configuring yabai easier and more fun!

Setting up Hammerspoon

To get started with Hammerspoon, can download and install it from the official website, or run the following command if you have homebrew installed on your machine.

brew install hammerspoon --cask

Once you’ve installed Hammerspoon, you can open the Hammerspoon console by pressing Command + Option + Control + H.

Setting up the Hammerspoon Configuration File

To set up the Hammerspoon Configuration File:

Open or create a file named ~/.hammerspoon/init.lua in your Hammerspoon configuration directory. You can find the directory by opening Hammerspoon and selecting “Open Config” from the menu bar.
Add your desired configuration code to the init.lua file. This can include defining hotkeys, creating window management functions, and more. You can find examples and documentation on the Hammerspoon website. We will be adding yabai hotkeys in the next step.
Save the init.lua file and reload your Hammerspoon configuration by selecting “Reload Config” from the Hammerspoon menu bar. Your changes should now take effect.
Optionally, you can also use a third-party tool like Spoons to manage your Hammerspoon configuration more easily. Spoons are modular extensions that can be loaded into Hammerspoon to provide additional functionality. For now, I will show you how to create your own keybindings with Lua.

Defining configuration file for yabai

Since hammerspoon can be used to configure more than just yabai keybindings, I prefer separating it. Thankfully, Lua offers a require function to import a separate file. Add this to your ~/.hammerspoon file:

require("keyboard.yabai")

Creating reusable functions for configuration

Now, you can create a directory in your ~/.hammerspoon directory called keyboard, then create a file called ~/.hammerspoon/keyboard/yabai.lua .

Sending Yabai Messages

In the yabai.lua config, create a reusable function called yabai that will execute the binary and run a message, make sure to run which yabai to confirm the path to your binary is /opt/homebrew/bin/yabai. Replace it if you get a different value.

-- Send message(s) to a running instance of yabai.
local function yabai(commands)
  for _, cmd in ipairs(commands) do
    os.execute("/opt/homebrew/bin/yabai -m " .. cmd)
  end
end

The for loop is being used so we can pass multiple messages in one function. For example, moving windows to a new desktop and focusing the desktop at the same time.

Configure `alt+{key}` Keybindings

I prefer using the alt key to drive all of my yabai commands, here is a reusable function for binding to alt+{key} and an argument to pass the yabai commands.

local function alt(key, commands)
  hs.hotkey.bind({ "alt" }, key, function()
    yabai(commands)
  end)
end

-- alpha
alt("f", { "window --toggle zoom-fullscreen" })
alt("l", { "space --focus recent" })
alt("m", { "space --toggle mission-control" })
alt("p", { "window --toggle pip" })
alt("g", { "space --toggle padding", "space --toggle gap" })
alt("r", { "space --rotate 90" })
alt("t", { "window --toggle float", "window --grid 4:4:1:1:2:2" })

-- special characters
alt("'", { "space --layout stack" })
alt(";", { "space --layout bsp" })
alt("tab", { "space --focus recent" })

Configure `alt+{number}` Keybindings for Spaces

In order to configure numbers 1-9 with keybindings, we will add a altShift function and altShiftNumber then loop through those numbers with a for loop turn each number into a string and enable the configurations to focus a desktop space with alt+{number} and move the current window in focus to another desktop space and then focus on the new space the window is now on. This second function, triggered by alt+shift+{number}.

Note: System Integrity Protection needs to be disable in order for yabai to focus a different desktop space. It is a helpful use-case but I realize some people can’t disable this feature. Please be aware of the security risks involved when disabling this feature.

local function altShift(key, commands)
  hs.hotkey.bind({ "alt", "shift" }, key, function()
    yabai(commands)
  end)
end

local function altShiftNumber(number)
  altShift(number, { "window --space " .. number, "space --focus " .. number })
end

for i = 1, 9 do
  local num = tostring(i)
  alt(num, { "space --focus " .. num })
  altShiftNumber(num)
end

Configure `alt+{hjkl}` Keybindings as Arrow Keys

Finally, use hjkl to focus on or move to a different window on your desktop. Holding alt+shift will swap the window instead.

local homeRow = { h = "west", j = "south", k = "north", l = "east" }

for key, direction in pairs(homeRow) do
  alt(key, { "window --focus " .. direction })
  altShift(key, { "window --swap " .. direction })
end

Save the init.lua and yabai.lua files and reload your Hammerspoon configuration by selecting “Reload Config” from the Hammerspoon menu bar. Your changes should now take effect.

Conclusion

You can customize this script to create your own keyboard bindings for yabai. For example, you could bind a key combination to change the size of a window or toggle between layouts. man yabai can be run in your terminal to read more about the available messages that are supported.

Customizing your keyboard bindings for yabai using Hammerspoon and the Lua programming language improves my workflow productivity, making it easy to use reusable functions and loops to quickly create and update my keybindings.

You can check out the whole yabai.lua config here or checkout my latest config here.

With Hammerspoon, you can create custom keyboard shortcuts to control yabai in any way you see fit, I recommend making it your own and adding and removing whatever works best for your workflow.

Thanks for getting to the end, I recommend checking out my introduction to yabai and how I use it in: Blazing Fast Window Management on macOS.

Optimizing Obsidian for Content Creation

Fri, 14 Apr 2023 12:00:00 GMT

My friend, Brandon Boswell, recently sat down again with me. I’m in the process of adopting Obsidian. We cover what Brandon has learned over the last 2 years of using Obsidian and some tips he’s found for finishing the creative process to actually deliver more content. We also cover a bunch of tips and best practices for getting the most out of Obsidian.

Abhishek Keshri's Dev Workflow

Thu, 23 Mar 2023 18:00:00 GMT

The conversation is about me and Abhishek’s developer environment setup. We discuss our use of various tools and plugins, including Lazygit, fuzzy-finder, and Catppuccin for transparency. We also discuss different key bindings for Git and file management, and our use of abbreviations in our shell environment. We share tips and tricks for optimizing our workflow, and express an interest in trying out each other’s favorite tools. The conversation ends with an agreement to keep in touch and share updates on our respective setups.

Resources

tmux Nerd Font window name plugin

Wed, 01 Mar 2023 18:00:00 GMT

Automatically rename your tmux windows to Nerd Font icons.

View on GitHub

Prerequisites

How to install

1. Install tpm plugin

This script can be installed with the Tmux Plugin Manager (tpm).

Add the following line to your ~/.tmux.conf file:

set -g @plugin 'joshmedeski/tmux-nerd-font-window-name'

How it works

When installed, your window names will automatically update to a Nerd Font that matches the activity (ex: vim, bash, node, ect…).

Contributing

I encourage contributors! I want to make this plugin the best it can be. Feel free to fork it and submit pull requests with any new ideas or improvements you have.

View on GitHub

vim + tmux with Nick Nisi

Thu, 23 Feb 2023 18:00:00 GMT

Nick and I talk about our developer workflows and what tools we’re finding interesting in the world of tmux and neovim.

Resources

nicknisi/dotfiles

vim, zsh, git, homebrew, neovim - my whole world

joshmedeski/dotfiles

Josh's dotfiles for his developer environment

Clutter Free macOS

Wed, 14 Dec 2022 18:00:00 GMT

I have a minimal, clutter-free, setup on my macOS environment, using tools like tmux and Vim. I have customized my settings to hide the dock and menu bar, and I prefer to use keyboard shortcuts rather than menu items. I also use a window manager and a transparent border for my terminal. I find this setup to be peaceful and conducive to focus, as it removes distractions and allows me to be more productive.

The two most helpful settings for making macOS clutter free are in the “Desktop & Dock” settings in macOS Ventura.

What is the terminal?

Thu, 27 Oct 2022 12:00:00 GMT

Terminology related to the terminal are often misinterpreted. The terminal is kind of a scary thing for some people. So I want to demystify how it works and break down the different terms.

Terminal App

A terminal application is a computer program that emulates the terminal environment on your computer. Every operating system comes with a built-in terminal application, but there are many third-party applications that can be found online (both open-source and paid).

Shell Environment

Next, the shell is an environment to interact with your computer. There are multiple shell environments to choose from, but they all have a base set of commands (like cd, ls, and pwd) that allows you to interact with your computer at a lower-level.

The most basic shell environment is sh and the most common is bash. In recent years, Apple decided to make zsh their default shell and I, personally, use one called fish. Each one offers different features and each can be customized in different ways.

If your not sure which shell environment you are using, running echo $SHELL will output your shell.

Extending Functionality

Once you have chosen and setup your shell environment, you can continue to extend the functionality of your terminal by adding third-party scripts called binaries. For example, fzf a fuzzy finder CLI (command-line interface). To install it, I recommend the homebrew package manager for macOS (brew install fzf).

Once installed, the fzf binary (which is a file) is stored to your path. The path is a set of directories for your shell environment to look for files that can run. This is defined in your shell environment and tools downloaded from brew are typically stored at /opt/homebrew/bin. There are also many binaries pre-installed on your computer (beyond zsh) in /usr/sbin.

The most important thing to know is that these scripts that your run have full access to your computer, so make sure to download them responsibly!

Closing Thoughts

Binaries or we can use third party package tools like home brew to install additional binaries onto our computer. I hope all of this makes sense. Let’s chat for a second.

I think the terminal is an interesting and exciting environment to do, complex things. You can automate your life in a lot of ways with this. Most importantly, as a programmer, you can develop and extend it. I recommend you ease into it, and take it one step at a time.

So that’s the terminal. Feel free to head to YouTube and leave a comment if you have any questions.

Smart tmux sessions with zoxide and fzf

Fri, 12 Aug 2022 12:00:00 GMT

Create and manage tmux sessions automatically with a custom script that uses zoxide and fzf.

Update: I’ve created an official tmux plugin called to make it easy to set this up in your workflow. View “t - smart tmux session manager” tmux plugin

zoxide

brew install zoxide

View zoxide on GitHub

tmux

brew install tmux

View tmux on GitHub

abbr tn "tmux new -s (pwd | sed 's/.*\///g')"

You can turn off the detach-on-destroy option in your tmux.conf to allow tmux to switch to an existing session when you close the final window on a session.

set-option -g detach-on-destroy off

macOS Binding

This is the macOS binding I use (cmd+j) to open the session manager popup.

key_bindings:
  - { key: K, mods: Command, chars: "\x02\x54" }

Watch “macOS Keyboard Shortcuts for tmux” for more details.

A Pretty Terminal in 5 minutes!

Tue, 05 Jul 2022 12:00:00 GMT

Here’s a quick guide on how to take your ugly terminal and make it pretty in just 5 minutes!

Here are all the important links:

live_config_reload: true

window:
  opacity: 0.85
  padding:
    x: 18
    y: 16
  dynamic_padding: false
  decorations: buttonless

font:
  normal:
    family: 'SFMono Nerd Font'
    style: Regular
  size: 22.0
  use_thin_strokes: true

https://gist.github.com/joshmedeski/d695b0d2ea64ab2c1b79286862070b00

Blazing Fast Window Management on macOS

Sun, 22 May 2022 12:00:00 GMT

An overview of how to manage macOS windows and desktops at blazing speeds!

Here is my yabai configuration (.yabairc)

#!/usr/bin/env sh

sudo yabai --load-sa
yabai -m signal --add event=dock_did_restart action="sudo yabai --load-sa"

# global settings
yabai -m config mouse_follows_focus          off
yabai -m config focus_follows_mouse          off
yabai -m config window_origin_display        default
yabai -m config window_placement             second_child
yabai -m config window_topmost               off
yabai -m config window_shadow                on
yabai -m config window_opacity               off
yabai -m config window_opacity_duration      0.0
yabai -m config active_window_opacity        1.0
yabai -m config normal_window_opacity        0.90
yabai -m config window_border                off
yabai -m config window_border_width          6
yabai -m config active_window_border_color   0xff775759
yabai -m config normal_window_border_color   0xff555555
yabai -m config insert_feedback_color        0xffd75f5f
yabai -m config split_ratio                  0.50
yabai -m config auto_balance                 off
yabai -m config mouse_modifier               fn
yabai -m config mouse_action1                move
yabai -m config mouse_action2                resize
yabai -m config mouse_drop_action            swap

# general space settings
yabai -m config layout                       bsp
yabai -m config top_padding                  15
yabai -m config bottom_padding               15
yabai -m config left_padding                 15
# NOTE: for OBS floating head
# yabai -m config left_padding                 450
yabai -m config right_padding                15
yabai -m config window_gap                   15

# apps to not manage (ignore)
yabai -m rule --add app="^System Settings$" manage=off
yabai -m rule --add app="^Archive Utility$" manage=off
yabai -m rule --add app="^Wally$" manage=off
yabai -m rule --add app="^Pika$" manage=off
yabai -m rule --add app="^balenaEtcher$" manage=off
yabai -m rule --add app="^Creative Cloud$" manage=off
yabai -m rule --add app="^Logi Options$" manage=off
yabai -m rule --add app="^Alfred Preferences$" manage=off
yabai -m rule --add app="Raycast" manage=off
yabai -m rule --add app="^Music$" manage=off

echo "yabai configuration loaded.."

This is my skhd configuration (.skhdrc)

# focus window
alt - h : yabai -m window --focus west
alt - j : yabai -m window --focus south
alt - k : yabai -m window --focus north
alt - l : yabai -m window --focus east

# swap managed window
shift + alt - h : yabai -m window --swap west
shift + alt - j : yabai -m window --swap south
shift + alt - k : yabai -m window --swap north
shift + alt - l : yabai -m window --swap east

# move managed window
shift + alt + ctrl - h : yabai -m window --warp west
shift + alt + ctrl - j : yabai -m window --warp south
shift + alt + ctrl - k : yabai -m window --warp north
shift + alt + ctrl - l : yabai -m window --warp east

# rotate tree
alt - r : yabai -m space --rotate 90

# toggle window fullscreen zoom
alt - f : yabai -m window --toggle zoom-fullscreen

# alt - s : yabai -m window --toggle
alt - s : yabai -m window --toggle sticky;\
          yabai -m window --toggle topmost;\
          yabai -m window --toggle pip

# toggle padding and gap
alt - g : yabai -m space --toggle padding; yabai -m space --toggle gap

# float / unfloat window and center on screen
alt - t : yabai -m window --toggle float;\
          yabai -m window --grid 4:4:1:1:2:2

# toggle window split type
alt - e : yabai -m window --toggle split

# balance size of windows
shift + alt - 0 : yabai -m space --balance

# move window and focus desktop
shift + alt - 1 : yabai -m window --space 1; yabai -m space --focus 1
shift + alt - 2 : yabai -m window --space 2; yabai -m space --focus 2
shift + alt - 3 : yabai -m window --space 3; yabai -m space --focus 3
shift + alt - 4 : yabai -m window --space 4; yabai -m space --focus 4
shift + alt - 5 : yabai -m window --space 5; yabai -m space --focus 5
shift + alt - 6 : yabai -m window --space 6; yabai -m space --focus 6
shift + alt - 7 : yabai -m window --space 7; yabai -m space --focus 7
shift + alt - 8 : yabai -m window --space 8; yabai -m space --focus 8
shift + alt - 9 : yabai -m window --space 9; yabai -m space --focus 9


# create desktop, move window and follow focus - uses jq for parsing json (brew install jq)
shift + alt - n : yabai -m space --create && \
                   index="$(yabai -m query --spaces --display | jq 'map(select(."native-fullscreen" == 0))[-1].index')" && \
                   yabai -m window --space "${index}" && \
                   yabai -m space --focus "${index}"

# fast focus desktop
alt - tab : yabai -m space --focus recent

# send window to monitor and follow focus
shift + alt - n : yabai -m window --display next; yabai -m display --focus next
shift + alt - p : yabai -m window --display previous; yabai -m display --focus previous

Resources

Additional Links

Update: In macOS Ventura, it has been moved to a “Mission Control” dropdown in the keyboard shortcut section.

My Dev Workflow - How I use fish, tmux, lazygit and neovim

Wed, 11 May 2022 03:09:27 GMT

This is a quick, raw walkthrough of my development workflow — all of it living in the terminal. I combine a few tools that each do one job well:

fish as my interactive shell
tmux for managing terminal sessions and windows
lazygit for fast, visual version control
Neovim as my editor

Together they let me move quickly without leaving the keyboard. Watch the video for a tour of how it all fits together.

How to add macOS Custom Keyboard App Shortcuts

Tue, 11 Jan 2022 22:16:20 GMT

macOS lets you assign your own keyboard shortcut to almost any menu command, in almost any app, right from System Preferences. It’s one of those built-in features that’s easy to overlook but pays off every day once you set it up.

In this quick video I’ll show you how to create custom app shortcuts so you can trigger the commands you use most without reaching for the mouse or hunting through menus.

How I Set Up Prettier

Tue, 28 Dec 2021 00:00:00 GMT

Prettier is a opinionated code formatter that allows you to create more consistent code automatically.

In this post, we are going to install, configure, and test Prettier on a TypeScript project.

Install Prettier

First, install the prettier package:

npm install -D prettier

Install plugin to sort imports

Next, install the sort imports Prettier plugin. I have found that being consistent with the order in which imports are imported goes a long way in a project.

npm install -D @trivago/prettier-plugin-sort-imports

Configure Prettier

Create a .prettierrc.json file in the root of your project

{
  "importOrder": ["^@/(.*)$", "^[./]"],
  "importOrderSeparation": true,
  "importOrderSortSpecifiers": true,
  "printWidth": 80,
  "proseWrap": "always",
  "semi": false,
  "singleQuote": true,
  "tabWidth": 2,
  "trailingComma": "none"
}

A few points about the rules I like to use:

80 characters as the print width works great for split screen windows and general legibility. 2 spaces as the tab width is enough to get the job done without sacrificing width space. The sort import plugin has ^@/(.*)$ in the first position of the array. You can map the root of your project to @/ by adding the following path to your tsconfig.json:

{
  "baseUrl": ".",
  "paths": {
    "@/_": ["./_"]
  }
}

Add Prettier Ignore

The quickest and safest way to have Prettier ignore files is by copying your .gitignore file:

cp .gitignore .prettierignore

Format all files

To format all files using Prettier, you can run the following CLI command. I highly recommend committing the work you’ve done so far to version control since this command will most likely change most of the files in your project.

npx prettier --write .

Final Thoughts

Prettier is an amazing solution for keeping your files formatted. I often don’t write my code in a prettier way, and have Prettier setup to run on save to auto format my files for me. You don’t have to deal with bad spacing, extra line breaks, and even the order of imports in your TypeScript files. This has been a huge time-saving tool for me over the last 5+ years and I now install Prettier in this way on all my projects.

Abbreviate Everything: Lessons from a Stenographer

Mon, 15 Nov 2021 12:00:00 GMT

From Vimconf 2021.

I hope it inspired you to start using text expanders and shorthand to start typing less and getting more done.

Note: The promotion in the video has expired, but reach to me on social media if you want to talk about your personal shorthand dictionary!

macOS Keyboard Shortcuts for tmux

Fri, 16 Jul 2021 17:55:00 GMT

As a longtime macOS user, I am used to using the command key to get a lot done. You’re probably familiar with cmd+c for copying to the clipboard, and cmd+t to create a new tab in Safari. Most power users agree that staying away from the mouse and keeping your hands on the keyboard for as long as possible will help you be faster and more efficient while working.

Unfortunately, tmux is a tool used in the terminal that doesn’t leverage the command key at all, but rather all of it’s commands are prefixed with the keystroke ctrl+b followed by a letter (ex: new window is ctrl+b c). I spent months building the muscle memory for the tmux keybindings, but it always felt slow compared to the macOS keyboard shortcuts.

So, using the Alacritty terminal emulator, I found a way to customize tmux with my own macOS style keyboard shortcuts using the command key.

In this article, I’m going to show you how to create your own keyboard shortcut for tmux. We will go through the following steps:

Decide the keyboard shortcut
Get the hex code
Assign it to Alacritty

1. Decide the keyboard shortcut

Before you can assign the keyboard shortcut you have to decide what you want it to do. tmux uses a prefix (default: control+b) followed by a key to run a key binding. In macOS, keyboard shortcuts are driven by the command key plus an additional key.

As an example, you can create a new tmux window with prefix+c. tmux windows share the same UI pattern as tabs in macOS (ex: Safari tabs or Finder tabs). New tabs in macOS are created with the cmd+t keyboard shortcut.

So let’s bind new tmux window to cmd+t.

2. Get the hex code

In order to simulate a keystroke, Alacritty uses hex codes, which is simply a combination of characters.

For our example, we need to get the hex code values for <ctrl+b> c. We will use xxd to record our keystrokes and dump the hex codes we need.

First run the following command (outside of tmux):

xxd -psd

Then type ctrl+b, c, then press the return key (aka enter). You will see the following data output in your terminal:

^Bc
02630a

Press ctrl+c to escape the xxd listener. You now have the hex code 02630a, which stands for ctrl+b c return.

3. Assign it to Alacritty

Keystroke hex codes are bound to two character at a time. So from our code 02630a, 02 stands for ctrl+b, 63 stands for c, and 0a stands for return. Since we don’t need the return key, we can drop it. Alacritty also wants us to escape each code with \x{hex} so the chars we want to use for <prefix-b> c will be \x02\x63.

Finally, we will use the key and mods keys to define the custom key binding. Add the following code to your ~/.config/alacritty/alacritty.yml config file.

key_bindings:
  - { key: T, mods: Command, chars: "\x02\x63" }

Now, while inside tmux, you can hit cmd+t to create a new window! The principles learned here can be applied to any key binding with any keystroke combination you can think of.

Bonus: Additional Shortcuts

Here are some of the tmux keybindings I have set up with Alacritty to create more macOS like keyboard shortcuts:

key_bindings:
  - { key: E, mods: Command, chars: "\x02\"" } # split tmux window vertically
  - { key: E, mods: Command|Shift, chars: "\x02%" } # split tmux window horizontally
  - { key: F, mods: Command, chars: "lfcd\n" } # open file manager 'gokcehan/lf'
  - { key: F, mods: Command|Shift, chars: "\x02\x5b\x2f" } # start tmux search mode
  - { key: G, mods: Command, chars: "\x02g" } # open git manager 'jesseduffield/lazygit'
  - { key: J, mods: Command, chars: "\x02\x54" } # open t - tmux smart session manager
  - { key: K, mods: Command, chars: "\x02s" } # open interactive tmux session client
  - { key: L, mods: Command, chars: "\x02L" } # switch to the last tmux session
  - { key: O, mods: Command, chars: "\x02u" } # open URLs 'joshmedeski/tmux-fzf-url'
  - { key: P, mods: Command, chars: ":GoToFile\n" } # files
  - { key: P, mods: Command|Shift, chars: ":GoToCommand\n" } # commands
  - { key: Q, mods: Command, chars: ":q\n" } # quit vim
  - { key: S, mods: Command, chars: "\x1b\x3a\x77\x0a" } # save vim buffer
  - { key: T, mods: Command, chars: "\x02c" } # create a new tmux window
  - { key: W, mods: Command, chars: "\x02x" } # kill the current pane
  - { key: Z, mods: Command, chars: "\x02z" } # toggle zoom state of the current tmux pane
  - { key: Tab, mods: Control, chars: "\x02n" } # switch to next tmux window
  - { key: Grave, mods: Control, chars: "\x02p" } # switch to previous tmux window
  - { key: Comma, mods: Command, chars: "\x02," } # rename the current tmux window
  - { key: LBracket, mods: Command, chars: "\x0f" } # navigate back in vim (ctrl+o)
  - { key: LBracket, mods: Command|Shift, chars: "\x02p" } # switch to next tmux window
  - { key: RBracket, mods: Command, chars: "\x09" } # navigate forward in vim (ctrl+i)
  - { key: RBracket, mods: Command|Shift, chars: "\x02n" } # switch to previous tmux window
  - { key: Semicolon, mods: Command, chars: "\x02:" } # enter the tmux command prompt
  - { key: Key1, mods: Command, chars: "\x021" } # select tmux window 1
  - { key: Key2, mods: Command, chars: "\x022" } #                ... 2
  - { key: Key3, mods: Command, chars: "\x023" } #                ... 3
  - { key: Key4, mods: Command, chars: "\x024" } #                ... 4
  - { key: Key5, mods: Command, chars: "\x025" } #                ... 5
  - { key: Key6, mods: Command, chars: "\x026" } #                ... 6
  - { key: Key7, mods: Command, chars: "\x027" } #                ... 7
  - { key: Key8, mods: Command, chars: "\x028" } #                ... 8
  - { key: Key9, mods: Command, chars: "\x029" } #                ... 9

To see my latest keybindings, check out my full alacritty.yml file on GitHub

How to Make an IKEA Hack Standing Desk

Wed, 19 May 2021 12:00:00 GMT

Standing desks have gained a lot of popularity in the last few years. At a previous job, I had a nice standing desk from

Popup history with tmux and fzf

Wed, 30 Dec 2020 12:00:00 GMT

ctrl-r is a great keyboard shortcut for viewing your terminal history and rerun commands.

Why I Switched from zsh to fish

Tue, 30 Jul 2019 12:00:00 GMT

I’ve been using the zsh terminal with the infamous oh-my-zsh framework for many years now. The features and improvements it makes on plain old bash are impressive. But as my needs change, so does my shell. I made the switch to the fish shell almost a year ago and here is why I switched.

Speed

fish is faster than zsh. Especially when using zsh plugins the loading time alone is significantly slower. But more than that, the overall experience for me feels snappier and more responsive in the fish shell. Since I’m using the terminal to be more efficient and get things done faster than a GUI, speed is one of my top requirements for my shell.

Simplicity

The oh-my-zsh configuration and plugins tend to add complexity to the terminal environment, especially custom aliases. Overall, I have found fish to be much simpler regarding configuration and usage. My config file is only a few lines long and I’m only using one or two plugins for third party utilities (ex: fasd and nvm). I also found a very simple theme that only shows me what I need, similar to my previous zsh theme.

Autosuggestion

This is the main reason I moved to fish. I originally was using the zsh-autosuggestions which is “Fish-like autosuggestions for zsh”. This is what drew me to fish, this is by far my most used feature. If I mistype a command, it will show in red to indicate that it’s an invalid command. But, more importantly, while I type the prompt auto-suggests my previous commands (by recent and most used). This is far quicker than ctrl+r and usually shows me the command I want 80%+ of the time. Again, this is the main reason I use fish and one of my favorite productivity tools on my computer, period.

Vim Mode

I’ve been a vim user for many years now. What I love about vim is it’s intuitiveness and efficiency (once you’ve really gotten it down). I know zsh offers a vim-mode but I was happy to learn fish has one as well. It a sort of simplified vi hybrid but it does all I need it to do.

Conclusion

fish is fast, simple, offers powerful autosuggestion and a vim mode. These are the most important thing for me right now in the terminal so I proudly made the switch to this friendly interactive shell and haven’t looked back.

Navigate the Web with Vim Keybindings

Sun, 06 Mar 2016 23:59:00 GMT

I've been using a tool for probably over a year now that helps let's me navigate the web with Vim. It's a chrome extension

How to Solve a Rubik's Cube

Thu, 11 Feb 2016 04:48:54 GMT

One of my earliest videos: a straightforward, beginner-friendly guide to solving a standard 3x3 Rubik’s Cube.

I walk through the layer-by-layer method one step at a time — solving the first layer, then the middle, and finally the last layer — so you can go from scrambled to solved without memorizing pages of notation.

This Four Letter Word Kills Productivity

Thu, 08 Jan 2015 16:18:00 GMT

Let's face it, there are a lot of things that can kill productivity; meetings, email, urgent matters given by co-workers

The Eisenhower Matrix and Todoist

Wed, 22 Oct 2014 09:20:00 GMT

The Eisenhower matrix is a productivity method to help you evaluate your work and decide what needs done in a more efficient manner.

Can't Keep up? Make a Waiting For List

Thu, 26 Jun 2014 00:00:00 GMT

You live in a world that depends on other people to get work done. On any day you could be waiting for a handful of people to take action on something before you can take the next step on a project. So how do you keep track of all those items?

In Getting Things Done (GTD), David Allen recommends creating a “waiting for” list that shows everything you are waiting for others to do. It’s recommended you date each item so that if you have to follow up with someone, you have a solid timeline. Remember this list is for items that require your attention after you have completed your part. (Sometimes you delegate work and you don’t have to follow up.)

Last month I won free tickets to a play at a local theater in town. The theater said I would receive an email with instructions for ordering my tickets. The day I won the tickets, I put “email from Stages Theater about free tickets won at Creative Mornings” in my “waiting for” list. Notice how specific I got, which also included the date I won the tickets as a reference.

Almost a full month later I still had not received the email, so I went to the theater website and filled out a contact form requesting information for my free tickets. The next day I got an email with clear instructions and an apology from the theater because the person in charge of my tickets was on vacation.

If I had not put this item on my “waiting for” list, I might have forgotten about the show. Thanks to this helpful tool, I was able to see a great show because it wasn’t forgotten.

There are more important items that can go on your “waiting for” list than free tickets to a play. What if you’re waiting for a proposal to be written, an invoice to be paid, or a doctor’s report to come in? The “waiting for” list becomes a necessity in cases like these.

And most importantly, if you have multiple items pending at the same time, this tool is a worry-free alternative to ensure things aren’t missed.

To get started, get out a blank piece of paper, set a timer for ten minutes and write down everything you are waiting for from someone else. Feel free to move this list into your to-do app and make sure you visit this list at regularly scheduled intervals, or set reminders on your calendar for those time-sensitive items.

You will be amazed at how smart you look when you follow up with a cold lead, a delayed email, or a software update when the rest of the world around you lets these little things get missed in this busy world.

Bullet Journal Didn't Work for Me

Mon, 16 Jun 2014 15:24:00 GMT

The Bullet Journal is an analog productivity system used for capturing everything during your day (todos, appointments, notes). Everything is written down in one chronological list. Each month you clean up your list and sort through whatever todos haven’t been check off yet. The creator, Ryder Carroll, described it as…

…an analog system for the digital age that will help you organize the present, record the past, and plan for the future.

Using this system for a couple weeks, I quickly learned the Bullet Journal is not for me. Here are a few reasons why.

Legibility

My handwriting isn’t terrible, but it’s also not great so having to figure out what I wrote tends to slow down my productive momentum. You could argue my handwriting would improve if I practiced using the Bullet Journal, but I’d rather separate handwriting skills from my productivity system, that’s just me.

GTD

The #1 reason why the Bullet Journal didn’t work for me is because I’m a avid Getting Things Done (GTD) user. In GTD, you collect any/every thought, idea, project, and reference material into an inbox. You then process the inbox and sort each item according to it’s purpose and refining everything in the weekly review. With the Bullet Journal, everything goes into a single journal with no opportunity to sort the items. I found it really hard to differentiate next actions, appointments, projects, someday/maybes, waiting for items, etc…

An argument could be made against the GTD system, because people like the Bullet Journal’s simplicity. I totally understand that, but I’ve been living by the GTD system for years, which makes transitioning to the Bullet Journal practices extremely difficult and not worth my time.

Search

The awesome thing about the productivity apps I currently use (Todoist, Trello, Evernote, Dropbox) is the power of search. I can quickly and easily write notes, add tags, attach images, and with Evernote I can scan in my handwritten notes and everything is searchable.

With the Bullet Journal, you create a table of contents and label every page for “easy” access. It felt like I was in middle school again trying to review for a test by constantly referencing the table of content and skimming the journal to find what I wanted.

Again, some people love analog systems and the ability to flip through pages and see their life in action. Before my Bullet Journal experiment, I created a Done Journal, writing down the day’s accomplishments and meaningful events. It was fun being able to flip though pages and remember the past, but I stopped the done journal after a couple months because it sucked up time and energy I thought could be better spent on my digital journal. The Bullet Journal is a similar situation because it sucks up a lot of time and energy but I don’t feel it is the best use of my time and energy.

Speed

I can type 100 word per minute. So you can imagine that physically writing on paper can slows me down. Bullet Journal users claim that having to write things down intentionally slows them down so they have time to evaluate if the task is worth their efforts. For me, GTD has taught me how to properly write a good todo item. It doesn’t matter if I write it down on paper or type it into a todo app.

Revisions

50% of my thoughts that get collected don’t go in my todo app, and even the remaining 50% of tasks get revised for more clarity. It would take me forever to write a task 2-3 times on a piece of paper which usually happens digitally.

It’s possible I’m not great at writing todos, and the Bullet Journal could help me improve, but I don’t think that’s the case. It’s not a matter of being good or bad at assembling todo items, it’s about revising todos as clarity and purpose for a project evolves. The GTD practice of daily and weekly evaluation helps me stay on top of my todos with a far greater degree of productivity than the Bullet Journal did.

Well that’s my thoughts on why the Bullet Journal didn’t work for me. I’m a strong GTD user and really like the workflow David Allen created, which I have not found to be benefitted by Bullet Journal practices.

I find the power of search with digital solutions extremely helpful, I prefer typing to hand writing, I want to bring revisions to my todos more frequently and I want to be able to easily read, and understand my tasks at a glance. All of these things are unfortunately not compatible with the Bullet Journal.

How I Do my Weekly Review

Thu, 01 May 2014 20:24:00 GMT

A good weekly review is important in my productivity. It allows me to evaluate my recent actions and plan out the following week. The weekly review also gives me a chance to catch up with everything.

I’ve been a big GTD (Getting Things Done) user for many years now, but I never set realistic expectation on my weekly review, and to be honest, I didn’t consistently do it. Over the past few months that perspective has changed and I have created a set routine and dedication to the weekly routine. It has completely transformed my productivity and focus.

Let me tell you about what my weekly review looks like. And show you why it’s so important to be intentional and dedicated to the weekly review.

Friday Afternoon

My weekly review is every Friday, without fail. I’ve been able to do this for a few months now and I schedule my entire week around it. I usually do interesting things Friday morning (like Creative Mornings or spend time with friends). But I never schedule meetings or appointments Friday afternoon, it’s my day.

Cleanup

Before I sit down and do the review, I have also made it house cleaning day. So I start the laundry, clean the dishes, clean up loose paperwork, recycling, and whatever else is not where it’s supposed to be.

Now that I have a clean house I’m ready to start.

Catching Up

I use Todoist as my todo app. I’ve scheduled a weekly task called “Weekly Review” and inside of it I have the following sub-tasks:

Pull out all loose papers, receipts, posts-its, etc…
Clear off desk
Empty paper inbox
Empty email inbox
Review todo emails
Empty “Downloads” folder
Empty voicemail
Review Feedly
Review Pocket
Budget in YNAB
Review previous & upcoming events
Review completed items
Go through the collection triggers (brain dump)
Review projects
Review next actions (are the accurate? Can all of it be done this coming week?)
Review waiting for (is it still worth waiting for? Is there a next action?)
Review someday/maybe (could I do it this week? Or ever?)
Review goals (what have I done to get closer to those goals?)

This is useful because I don’t have to remember what to do in my weekly review, and I don’t have to go looking for it when it comes time to start reviewing. It’s also a great reminder in case my morning is busy (because Todoist is almost always open on my computer).

The list is pretty strait forward, and many of the items only take a few seconds to do. It’s meant to be thorough so that I don’t have to think during this process. I go through and check of each item. If something doesn’t make sense to me or I skip the task more than one week, I make revision for the future weekly review.

If you noticed, most of the tasks have to do with emptying. That’s because during the week I don’t want to have to deal with this stuff. But every week I want a fresh start. Plus I tend to miss less things if I check these places every week.

Brain Dump

Part of my weekly review involves a brain dump. I go through the following list with Todoist’s collection trigger feature and try to think of anything that’s on my mind.

Open projects (websites, part-time, other)
Upcoming events (work, family, community)
Communication (calls, emails)
Errands (groceries, recycling, Walmart, car)
Home (cleaning, laundry, fixing, sort)
Tech (software, hardware, updates)
Health (hair, medicine, doctor, dentist)
Hobbies (art, music, Rubik’s cube)
Media (movies, books, podcasts)
Community (volunteering, relationships)
Community (teaching, volunteering)
Someday (art, products, trip, event)
Houston (Meetups, events)

I’m not totally happy with these triggers at this point. So I may try to reevaluate how to phrase these tricks (possibly putting them in question form?). Overall I do my best to write something down the minute I think of it, but in the weekly review there are always a few things that come up! Sometimes it’s the weirdest things, like that restaurant I want to go eat at, that hobby I’ve been neglecting, or the invoice that I need to follow up on. I’m sure the brain dump can happen more than once a week, but it’s been the right amount of time for my brain to handle.

Reflecting

This last part I learned from my life coach, Whitney Hutten. I ask myself the following questions to make sure that I’m actually focusing on what’s most important and aligning my tasks with my values. This is the higher thinking GTD talks about, and I’ve found it to be the missing link for me from being busy vs being productive.

What went well?
What could be adjusted?
What to stop doing?
What to start doing?
What to continue doing?

That’s my weekly review! It adapts and changes over time, but the principles remain the same. Schedule a consistent time, catch up, brain dump, reflect. I’ve found it invaluable and I hope looking into my weekly review will shape your weekly review or get you started on actually making it happen!

3 Tips to Overcome Perfectionism

Sun, 20 Apr 2014 08:00:00 GMT

Perfectionism is stopping you from growing your business, building your cause, and doing what you love. It’s important to face this problem head on. Here are 3 tips to overcome perfectionism.

Get yourself out there

My advice to overcome perfectionism is remind yourself that nothing’s perfect the first time around. You just have to get your product, opt-in, blog post, podcast, video, newsletter, book, performance out there and see what happens. Getting yourself out there is the first step.

People don’t like perfect (be authentic instead)

I’ve been working on a personal project for over 6 months now and I realize that people don’t like perfect. In fact, authenticity is more important than perfection. It something is too “perfect” it comes off as too-good-to-be-true and unauthentic (or even sleazy). You have to do you best work and allow your flaws to show in order to win people’s trust.

There is no “RIGHT” way

There is always more than one way to do something, and your never going to know which way is best for you until you make mistakes and learn the wrong way to do it.

I have not failed. I’ve just found 10,000 ways that won’t work.
Thomas Edison

Well that’s just a few ways for you to overcome perfectionism.

Deleting Mac Apps in Record Time

Fri, 11 Apr 2014 08:00:00 GMT

Here's a quick and simple solution for deleting Mac apps in record time! It uses Alfred, my favorite productivity app

Josh Medeski

Tuning Your Claude Code Settings

The Case for Breaks in the AI Era

The Hidden Cost of Node.js Flexibility

Node.js Doesn’t Care (Until It Does)

The Order Problem

Why This Happens

But It Works in Production…

What Good Actually Looks Like

The Gap Between Ideal and Reality

The Compounding Problem

The Actual Fix: Think Top-Down

What I Haven’t Solved

The Takeaway

How To Use Git Worktrees to Switch Contexts Quickly and Easily

Why Use Git Worktrees?

Setting Up the Directory Structure

Tip: Cleaner shell history

Creating Worktrees

Naming Conventions and Branch Management

Optimizing Your Workflow with Tools

Session Management with Sesh

Code Reviews with GH Dash and Octo

Cleaning Up with Treekanga

Conclusion

Instantly Open Any Website Using Raycast

SearchXNG

Leveraging Search Engine Skills

Introducing “Bangs” and Auto Redirects

Example Searches

Setting Up with Raycast

Supercharging with a Keyboard Shortcut

Why This Workflow Works for Me

I made my favorite tmux feature better with sesh

tmux last command

macOS keybinding

The problem

Introducing sesh last

In conclusion

AI in Neovim (NeovimConf 2024)

Completion

My Choice

Alternatives

Configuration

Chat

My Choice

Alternatives

Configuration

Generation

My Choice

Alternatives

Configuration

Conclusion

Carlos Beckers's Dev Workflow

Smart tmux sessions with sesh

Intro

How to install

How it works

Getting Started

Startup

macOS keybinding

Naming Sessions

Custom configs

Default Startup

Raycast

Adding to Zoxide

Wrapping Up

Switching from Mackup to Stow Dotfiles Manager

The Challenge with Mackup

Introducing GNU Stow

Moving Dotfiles from Mackup to Stow

Conclusion

Top 4 Fuzzy CLIs

Installation

4. zf

3. gum

2. skim

1. fzf

Make Your Yearly Review Easier with AI

The Tools

Introducing `sesh last`

References (`]]` & `[[`)

Buffers (`]b` & `[b`)

Git Hunks (`]g` & `[g`)

LSP Diagnostics (`]d` & `[d`)

LSP Errors (`]e` & `[e`)

LSP Warnings (`]w` & `[w`)

TODO Comments (`]t` & `[t`)

Classes & Functions (`]c` & `[c`)

Functions (`]f` & `[f`)

1. Create a `<GhRepo />` Astro component