The world has changed at such a fast pace in the last few years that it is impossible to keep up with all the new technologies, practices, and tools. When looking at the software community these days, it is very common to find people building individual workarounds that are tailored to their own needs and are opinionated based on their own experiences. And I am no exception to that.
I have kept the same set of tools in my toolbox for the past few years, and every time I tried to replace one or more of them with something else, I soon found myself going back to
the same old tools: vim, Kitty, and lazygit. This is why I have been a sponsor for Kitty and lazygit through GitHub; despite being a very
small contribution, I feel I owe it to the maintainers of these projects for making my life easier and more productive.
And as a way of giving back to the community, I have decided to open-source two of my own vibe-coded, opinionated tools built on top of them in this post.
Built on top of herdr, kitherd turns Kitty into a TUI interface for agentic orchestration. It is a combination of an AI skill and a simple wrapper script, and aims to
replace herdr panes with Kitty’s native splits. kitherd relies on Kitty’s remote control feature to send and receive commands to and from the background herdr server.
Because I found it absurd to deal with two layers of interfaces for splitting my terminal screen, where I had to learn and configure herdr’s keybindings in a way that avoids conflicts
with Kitty’s—and all this with the overhead of dealing with terminal multiplexers and how slow they are at rendering the screen.
kitherd can be easily used once it is installed. The developer can simply mention use kitherd skill to spawn new worker agents… in their main agent, and it already knows how to
open, close, and manage external agents with Kitty’s native features. It has been tested to work properly with popular harnesses, such as Claude Code, Codex, Opencode, Pi, and
even Antigravity CLI.
Since kitherd is only an interface over the herdr server, any split that holds a worker agent can be closed without the worker being affected. All workers will continue
running in the background, and using a simple keybinding (such as alt+a), the developer can see background agents and their status, and decide to attach to or kill them. This level
of control lets a developer handle an unlimited number of worker agents through one mastermind (well, as unlimited as herdr can support).
If you are a Nix user, the installation is as simple as adding kitherd’s flake to your flake.nix inputs. If not, you can always clone and install the skill manually. Instructions
and other information are available on the project’s repository on my GitHub.
This project is relatively newer than kitherd, but I have already been using it for months. The idea of this project is to extend lazygit with a new panel showing Pull Requests
on GitHub through gh for the open repository. This project lets me have a good level of control over Pull Requests, while still staying in the same program and using familiar
keybindings for them.
Lazygithub has currently been tested against v0.61.1, as this is the version available for NixOS 26.05, which is the version I use across my NixOS and nix-darwin systems.
The idea behind this project is to have a one-to-one patch provided for lazygit’s versions. While it is not possible to provide a patch for all versions, I try to keep the patch
updated for the versions installed through the NixOS Stable channel.
I have decided against “forking” lazygit for this project. For one, I don’t think of lazygithub as a fork; it is definitely a patch for a specific version. I do not
intend to have separate releases, and I do not want fork syncing to introduce the risk of constant conflicts to this patch. Patches are tagged with the same version as lazygit,
so at any point they can be moved higher or lower.
And this project exists because lazygit’s maintainers have decided not to adopt GitHub Pull Requests in the past. There are various discussions about this topic that you can find
with a quick search. This patch, however, can be merged into the upstream repository at any time contributors decide to adopt it.
With the patch applied, the PR(gh) tab shows up in the 3rd panel, next to Local branches. The tab shows a list of Pull Requests for the repository, the author, status (draft, approved, changes requested), and can be customized to filter results in the configuration.
When a PR is selected in the list, the PR’s description is rendered using the glow library, which supports rich text in Markdown and HTML formats. The description shows
workflows run for the PR and their status, as well as approval status and comments, while resolved comments are marked and hidden to keep the output less cluttered.
By pressing enter on a PR, the developer can see its commits without checking out the branch, in the familiar format of a local branch. Each commit can also be opened to
show a list of file changes, where the developer can leave comments on changes by selecting them.
This set of features has made me (almost) independent of using a browser for basic Pull Request work. I can comment on a PR or on a specific change, approve it or request changes, see workflow statuses, and read all comments, while keeping my work going in the background with my AI agents.
As with kitherd, installation is simple if you are a Nix user. Otherwise, the repository has a simple set of make commands that let you clone the lazygit
submodule and apply the patch; however, you will need to build lazygit manually after applying the patch. For more details, see the projects’ repository on my GitHub.
We are living in a magical time, where building is now only limited by how far our imaginations can extend. We can iterate over our day-to-day work, identify improvement opportunities, and patch them ourselves. We can build, test, and publish ideas we’ve had for decades in our spare time, right after our full-time job is over. All we need these days is ambition.
This post, however, was fully written by a human. Proofreading was the only part done by AI.